remove fp-self-contained and migrate template to use new extrinsic format

Author: vedhavyas

Cargo.lock

@@ -32,7 +32,6 @@ members = [
 	"primitives/dynamic-fee",
 	"primitives/evm",
 	"primitives/rpc",
-	"primitives/self-contained",
 	"template/node",
 	"template/runtime",
 	"precompiles",
@@ -190,7 +189,6 @@ fp-dynamic-fee = { path = "primitives/dynamic-fee", default-features = false }
 fp-ethereum = { path = "primitives/ethereum", default-features = false }
 fp-evm = { path = "primitives/evm", default-features = false }
 fp-rpc = { path = "primitives/rpc", default-features = false }
-fp-self-contained = { path = "primitives/self-contained", default-features = false }
 fp-storage = { path = "primitives/storage", default-features = false }
 # Frontier FRAME
 pallet-base-fee = { path = "frame/base-fee", default-features = false }

Cargo.toml

@@ -38,8 +38,6 @@ rlp = { workspace = true }
 pallet-balances = { workspace = true, features = ["default", "insecure_zero_ed"] }
 pallet-timestamp = { workspace = true, features = ["default"] }
 sp-core = { workspace = true, features = ["default"] }
-# Frontier
-fp-self-contained = { workspace = true, features = ["default"] }
 
 [features]
 default = ["std"]

frame/ethereum/Cargo.toml

@@ -45,16 +45,14 @@ use scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 // Substrate
 use frame_support::{
-	dispatch::{
-		DispatchErrorWithPostInfo, DispatchInfo, DispatchResultWithPostInfo, Pays, PostDispatchInfo,
-	},
+	dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Pays, PostDispatchInfo},
 	traits::{EnsureOrigin, Get, PalletInfoAccess, Time},
 	weights::Weight,
 };
-use frame_system::{pallet_prelude::OriginFor, CheckWeight, WeightInfo};
+use frame_system::{pallet_prelude::OriginFor, WeightInfo};
 use sp_runtime::{
 	generic::DigestItem,
-	traits::{DispatchInfoOf, Dispatchable, One, Saturating, UniqueSaturatedInto, Zero},
+	traits::{One, Saturating, UniqueSaturatedInto, Zero},
 	transaction_validity::{
 		InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransactionBuilder,
 	},
@@ -105,76 +103,6 @@ impl<O: Into<Result<RawOrigin, O>> + From<RawOrigin>> EnsureOrigin<O>
 	}
 }
 
-impl<T> Call<T>
-where
-	OriginFor<T>: Into<Result<RawOrigin, OriginFor<T>>>,
-	T: Send + Sync + Config,
-	T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
-{
-	pub fn is_self_contained(&self) -> bool {
-		matches!(self, Call::transact { .. })
-	}
-
-	pub fn check_self_contained(&self) -> Option<Result<H160, TransactionValidityError>> {
-		if let Call::transact { transaction } = self {
-			let check = || {
-				let origin = Pallet::<T>::recover_signer(transaction).ok_or(
-					InvalidTransaction::Custom(TransactionValidationError::InvalidSignature as u8),
-				)?;
-
-				Ok(origin)
-			};
-
-			Some(check())
-		} else {
-			None
-		}
-	}
-
-	pub fn pre_dispatch_self_contained(
-		&self,
-		origin: &H160,
-		dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
-		len: usize,
-	) -> Option<Result<(), TransactionValidityError>> {
-		if let Call::transact { transaction } = self {
-			if let Err(e) =
-				CheckWeight::<T>::do_validate(dispatch_info, len).and_then(|(_, next_len)| {
-					CheckWeight::<T>::do_prepare(dispatch_info, len, next_len)
-				}) {
-				return Some(Err(e));
-			}
-
-			Some(Pallet::<T>::validate_transaction_in_block(
-				*origin,
-				transaction,
-			))
-		} else {
-			None
-		}
-	}
-
-	pub fn validate_self_contained(
-		&self,
-		origin: &H160,
-		dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
-		len: usize,
-	) -> Option<TransactionValidity> {
-		if let Call::transact { transaction } = self {
-			if let Err(e) = CheckWeight::<T>::do_validate(dispatch_info, len) {
-				return Some(Err(e));
-			}
-
-			Some(Pallet::<T>::validate_transaction_in_pool(
-				*origin,
-				transaction,
-			))
-		} else {
-			None
-		}
-	}
-}
-
 #[derive(Copy, Clone, Eq, PartialEq, Default)]
 pub enum PostLogContent {
 	#[default]

frame/ethereum/src/lib.rs

@@ -21,17 +21,20 @@ use ethereum::{TransactionAction, TransactionSignature};
 use rlp::RlpStream;
 // Substrate
 use frame_support::{derive_impl, parameter_types, traits::FindAuthor, ConsensusEngineId};
+use frame_system::{CheckSpecVersion, CheckWeight};
 use sp_core::{hashing::keccak_256, H160, H256, U256};
-use sp_runtime::{
-	traits::{Dispatchable, IdentityLookup},
-	AccountId32, BuildStorage,
-};
+use sp_runtime::generic::{CheckedExtrinsic, ExtrinsicFormat};
+use sp_runtime::{traits::IdentityLookup, AccountId32, BuildStorage};
 // Frontier
-use pallet_evm::{config_preludes::ChainId, AddressMapping};
-
 use super::*;
+use crate::extension::EthereumExtension;
+use pallet_evm::{config_preludes::ChainId, AddressMapping};
 
-pub type SignedExtra = (frame_system::CheckSpecVersion<Test>,);
+pub type SignedExtra = (
+	frame_system::CheckSpecVersion<Test>,
+	frame_system::CheckWeight<Test>,
+	crate::extension::EthereumExtension<Test>,
+);
 
 frame_support::construct_runtime! {
 	pub enum Test {
@@ -104,62 +107,14 @@ impl pallet_evm::Config for Test {
 #[derive_impl(crate::config_preludes::TestDefaultConfig)]
 impl Config for Test {}
 
-impl fp_self_contained::SelfContainedCall for RuntimeCall {
-	type SignedInfo = H160;
-
-	fn is_self_contained(&self) -> bool {
-		match self {
-			RuntimeCall::Ethereum(call) => call.is_self_contained(),
-			_ => false,
-		}
-	}
-
-	fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {
-		match self {
-			RuntimeCall::Ethereum(call) => call.check_self_contained(),
-			_ => None,
-		}
-	}
-
-	fn validate_self_contained(
-		&self,
-		info: &Self::SignedInfo,
-		dispatch_info: &DispatchInfoOf<RuntimeCall>,
-		len: usize,
-	) -> Option<TransactionValidity> {
-		match self {
-			RuntimeCall::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len),
-			_ => None,
-		}
-	}
-
-	fn pre_dispatch_self_contained(
-		&self,
-		info: &Self::SignedInfo,
-		dispatch_info: &DispatchInfoOf<RuntimeCall>,
-		len: usize,
-	) -> Option<Result<(), TransactionValidityError>> {
-		match self {
-			RuntimeCall::Ethereum(call) => {
-				call.pre_dispatch_self_contained(info, dispatch_info, len)
-			}
-			_ => None,
-		}
-	}
-
-	fn apply_self_contained(
-		self,
-		info: Self::SignedInfo,
-	) -> Option<sp_runtime::DispatchResultWithInfo<sp_runtime::traits::PostDispatchInfoOf<Self>>> {
+impl crate::extension::EthereumTransactionHook<Test> for RuntimeCall {
+	fn maybe_ethereum_call(&self) -> Option<&Call<Test>> {
 		match self {
-			call @ RuntimeCall::Ethereum(crate::Call::transact { .. }) => {
-				Some(call.dispatch(RuntimeOrigin::from(RawOrigin::EthereumTransaction(info))))
-			}
+			RuntimeCall::Ethereum(call) => Some(call),
 			_ => None,
 		}
 	}
 }
-
 pub struct AccountInfo {
 	pub address: H160,
 	pub account_id: AccountId32,
@@ -402,3 +357,66 @@ impl EIP1559UnsignedTransaction {
 		})
 	}
 }
+
+pub(crate) fn create_checked_extrinsic(
+	call: crate::Call<Test>,
+) -> CheckedExtrinsic<AccountId32, RuntimeCall, SignedExtra> {
+	CheckedExtrinsic::<_, _, SignedExtra> {
+		format: ExtrinsicFormat::General(
+			0,
+			(
+				CheckSpecVersion::<Test>::new(),
+				CheckWeight::<Test>::new(),
+				EthereumExtension::<Test>::new(),
+			),
+		),
+		function: RuntimeCall::Ethereum(call),
+	}
+}
+
+impl<T> Call<T>
+where
+	OriginFor<T>: Into<Result<RawOrigin, OriginFor<T>>>,
+	T: Send + Sync + Config,
+{
+	pub fn check_ethereum_call(&self) -> Option<Result<H160, TransactionValidityError>> {
+		if let Call::transact { transaction } = self {
+			let check = || {
+				let origin = Pallet::<T>::recover_signer(transaction).ok_or(
+					InvalidTransaction::Custom(TransactionValidationError::InvalidSignature as u8),
+				)?;
+
+				Ok(origin)
+			};
+
+			Some(check())
+		} else {
+			None
+		}
+	}
+
+	pub fn pre_dispatch_ethereum_call(
+		&self,
+		origin: &H160,
+	) -> Option<Result<(), TransactionValidityError>> {
+		if let Call::transact { transaction } = self {
+			Some(Pallet::<T>::validate_transaction_in_block(
+				*origin,
+				transaction,
+			))
+		} else {
+			None
+		}
+	}
+
+	pub fn validate_ethereum_call(&self, origin: &H160) -> Option<TransactionValidity> {
+		if let Call::transact { transaction } = self {
+			Some(Pallet::<T>::validate_transaction_in_pool(
+				*origin,
+				transaction,
+			))
+		} else {
+			None
+		}
+	}
+}