Remove UncheckedExtrinsic::function field

Author: serban300

substrate/client/offchain/src/lib.rs

@@ -473,7 +473,7 @@ mod tests {
 		// then
 		assert_eq!(pool.status().ready, 1);
 		assert!(matches!(
-			pool.ready().next().unwrap().data().function,
+			pool.ready().next().unwrap().data().call.try_decode().unwrap(),
 			RuntimeCall::SubstrateTest(PalletCall::storage_change { .. })
 		));
 	}

substrate/client/transaction-pool/src/common/tests.rs

@@ -24,8 +24,8 @@ use parking_lot::Mutex;
 use sc_transaction_pool_api::error;
 use sp_blockchain::{HashAndNumber, TreeRoute};
 use sp_runtime::{
-	generic::BlockId,
-	traits::{Block as BlockT, Hash},
+	generic::{BlockId, FullUncheckedExtrinsicRef},
+	traits::{Block as BlockT, Hash, LazyExtrinsic},
 	transaction_validity::{
 		InvalidTransaction, TransactionSource, TransactionValidity, ValidTransaction,
 	},
@@ -79,14 +79,14 @@ impl ChainApi for TestApi {
 		_source: TransactionSource,
 		uxt: ExtrinsicFor<Self>,
 	) -> Self::ValidationFuture {
-		let uxt = (*uxt).clone();
+		let mut uxt = (*uxt).clone();
 		self.validation_requests.lock().push(uxt.clone());
 		let hash = self.hash_and_length(&uxt).0;
 		let block_number = self.block_id_to_number(&BlockId::Hash(at)).unwrap().unwrap();
 
-		let res = match uxt {
-			Extrinsic {
-				function: RuntimeCall::Balances(BalancesCall::transfer_allow_death { .. }),
+		let res = match uxt.expect_as_full() {
+			FullUncheckedExtrinsicRef {
+				call: &RuntimeCall::Balances(BalancesCall::transfer_allow_death { .. }),
 				..
 			} => {
 				let TransferData { nonce, .. } = (&uxt).try_into().unwrap();
@@ -132,8 +132,8 @@ impl ChainApi for TestApi {
 					Ok(transaction)
 				}
 			},
-			Extrinsic {
-				function: RuntimeCall::SubstrateTest(PalletCall::include_data { .. }),
+			FullUncheckedExtrinsicRef {
+				call: &RuntimeCall::SubstrateTest(PalletCall::include_data { .. }),
 				..
 			} => Ok(ValidTransaction {
 				priority: 9001,
@@ -142,8 +142,8 @@ impl ChainApi for TestApi {
 				longevity: 9001,
 				propagate: false,
 			}),
-			Extrinsic {
-				function: RuntimeCall::SubstrateTest(PalletCall::indexed_call { .. }),
+			FullUncheckedExtrinsicRef {
+				call: &RuntimeCall::SubstrateTest(PalletCall::indexed_call { .. }),
 				..
 			} => Ok(ValidTransaction {
 				priority: 9001,

substrate/frame/election-provider-multi-block/src/mock/mod.rs

@@ -53,7 +53,7 @@ use sp_core::{
 use sp_npos_elections::EvaluateSupport;
 use sp_runtime::{
 	bounded_vec,
-	traits::{BlakeTwo256, IdentityLookup},
+	traits::{BlakeTwo256, IdentityLookup, LazyExtrinsic},
 	BuildStorage, PerU16, Perbill,
 };
 pub use staking::*;
@@ -625,8 +625,12 @@ pub fn roll_to_with_ocw(n: BlockNumber, maybe_pool: Option<Arc<RwLock<PoolState>
 				.clone()
 				.into_iter()
 				.map(|uxt| <Extrinsic as codec::Decode>::decode(&mut &*uxt).unwrap())
-				.for_each(|xt| {
-					xt.function.dispatch(frame_system::RawOrigin::None.into()).unwrap();
+				.for_each(|mut xt| {
+					xt.expect_as_full()
+						.call
+						.clone()
+						.dispatch(frame_system::RawOrigin::None.into())
+						.unwrap();
 				});
 			pool.try_write().unwrap().transactions.clear();
 		}

substrate/frame/election-provider-multi-block/src/unsigned/miner.rs

@@ -1620,12 +1620,13 @@ mod base_miner {
 
 #[cfg(test)]
 mod offchain_worker_miner {
-	use crate::{verifier::Verifier, CommonError};
-	use frame_support::traits::Hooks;
-	use sp_runtime::offchain::storage_lock::{BlockAndTime, StorageLock};
-
 	use super::*;
-	use crate::mock::*;
+	use crate::{mock::*, verifier::Verifier, CommonError};
+	use frame_support::traits::Hooks;
+	use sp_runtime::{
+		offchain::storage_lock::{BlockAndTime, StorageLock},
+		traits::LazyExtrinsic,
+	};
 
 	#[test]
 	fn lock_prevents_frequent_execution() {
@@ -1751,11 +1752,11 @@ mod offchain_worker_miner {
 			// OCW must have submitted now
 
 			let encoded = pool.read().transactions[0].clone();
-			let extrinsic: Extrinsic = codec::Decode::decode(&mut &*encoded).unwrap();
-			let call = extrinsic.function;
+			let mut extrinsic: Extrinsic = codec::Decode::decode(&mut &*encoded).unwrap();
+			let call = extrinsic.expect_as_full().call;
 			assert!(matches!(
 				call,
-				crate::mock::RuntimeCall::UnsignedPallet(
+				&crate::mock::RuntimeCall::UnsignedPallet(
 					crate::unsigned::Call::submit_unsigned { .. }
 				)
 			));

substrate/frame/election-provider-multi-phase/src/unsigned.rs

@@ -1102,7 +1102,7 @@ mod tests {
 	use sp_runtime::{
 		bounded_vec,
 		offchain::storage_lock::{BlockAndTime, StorageLock},
-		traits::{Dispatchable, ValidateUnsigned, Zero},
+		traits::{Dispatchable, LazyExtrinsic, ValidateUnsigned, Zero},
 		ModuleError, PerU16,
 	};
 
@@ -1891,9 +1891,9 @@ mod tests {
 			// OCW must have submitted now
 
 			let encoded = pool.read().transactions[0].clone();
-			let extrinsic: Extrinsic = codec::Decode::decode(&mut &*encoded).unwrap();
-			let call = extrinsic.function;
-			assert!(matches!(call, RuntimeCall::MultiPhase(Call::submit_unsigned { .. })));
+			let mut extrinsic: Extrinsic = codec::Decode::decode(&mut &*encoded).unwrap();
+			let call = extrinsic.expect_as_full().call;
+			assert!(matches!(call, &RuntimeCall::MultiPhase(Call::submit_unsigned { .. })));
 		})
 	}
 
@@ -1908,8 +1908,8 @@ mod tests {
 			crate::Round::<Runtime>::mutate(|round| *round += 1);
 
 			let encoded = pool.read().transactions[0].clone();
-			let extrinsic = Extrinsic::decode(&mut &*encoded).unwrap();
-			let call = match extrinsic.function {
+			let mut extrinsic = Extrinsic::decode(&mut &*encoded).unwrap();
+			let call = match extrinsic.expect_as_full().call {
 				RuntimeCall::MultiPhase(call @ Call::submit_unsigned { .. }) => call,
 				_ => panic!("bad call: unexpected submission"),
 			};

substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs

@@ -32,7 +32,7 @@ use sp_runtime::{
 		OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,
 	},
 	testing,
-	traits::Zero,
+	traits::{LazyExtrinsic, Zero},
 	transaction_validity, BuildStorage, PerU16, Perbill, Percent,
 };
 use sp_staking::{
@@ -730,14 +730,16 @@ pub fn roll_to_with_ocw(n: BlockNumber, pool: Arc<RwLock<PoolState>>, delay_solu
 			// decode submit_unsigned callable that may be queued in the pool by ocw. skip all
 			// other extrinsics in the pool.
 			for encoded in &pool.read().transactions {
-				let extrinsic = Extrinsic::decode(&mut &encoded[..]).unwrap();
+				let mut extrinsic = Extrinsic::decode(&mut &encoded[..]).unwrap();
 
-				let _ = match extrinsic.function {
+				let _ = match extrinsic.expect_as_full().call {
 					RuntimeCall::ElectionProviderMultiPhase(
 						call @ Call::submit_unsigned { .. },
 					) => {
 						// call submit_unsigned callable in OCW pool.
-						crate::assert_ok!(call.dispatch_bypass_filter(RuntimeOrigin::none()));
+						crate::assert_ok!(call
+							.clone()
+							.dispatch_bypass_filter(RuntimeOrigin::none()));
 					},
 					_ => (),
 				};

substrate/frame/examples/offchain-worker/src/tests.rs

@@ -37,7 +37,7 @@ use sp_core::{
 use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
 use sp_runtime::{
 	testing::TestXt,
-	traits::{BlakeTwo256, IdentifyAccount, IdentityLookup, Verify},
+	traits::{BlakeTwo256, IdentifyAccount, IdentityLookup, LazyExtrinsic, Verify},
 	RuntimeAppPublic,
 };
 
@@ -245,9 +245,12 @@ fn should_submit_signed_transaction_on_chain() {
 		// then
 		let tx = pool_state.write().transactions.pop().unwrap();
 		assert!(pool_state.read().transactions.is_empty());
-		let tx = Extrinsic::decode(&mut &*tx).unwrap();
+		let mut tx = Extrinsic::decode(&mut &*tx).unwrap();
 		assert!(matches!(tx.preamble, sp_runtime::generic::Preamble::Signed(0, (), (),)));
-		assert_eq!(tx.function, RuntimeCall::Example(crate::Call::submit_price { price: 15523 }));
+		assert_eq!(
+			tx.expect_as_full().call,
+			&RuntimeCall::Example(crate::Call::submit_price { price: 15523 })
+		);
 	});
 }
 
@@ -285,12 +288,12 @@ fn should_submit_unsigned_transaction_on_chain_for_any_account() {
 		Example::fetch_price_and_send_unsigned_for_any_account(1).unwrap();
 		// then
 		let tx = pool_state.write().transactions.pop().unwrap();
-		let tx = Extrinsic::decode(&mut &*tx).unwrap();
+		let mut tx = Extrinsic::decode(&mut &*tx).unwrap();
 		assert!(tx.is_inherent());
 		if let RuntimeCall::Example(crate::Call::submit_price_unsigned_with_signed_payload {
 			price_payload: body,
 			signature,
-		}) = tx.function
+		}) = tx.expect_as_full().call.clone()
 		{
 			assert_eq!(body, price_payload);
 
@@ -340,12 +343,12 @@ fn should_submit_unsigned_transaction_on_chain_for_all_accounts() {
 		Example::fetch_price_and_send_unsigned_for_all_accounts(1).unwrap();
 		// then
 		let tx = pool_state.write().transactions.pop().unwrap();
-		let tx = Extrinsic::decode(&mut &*tx).unwrap();
+		let mut tx = Extrinsic::decode(&mut &*tx).unwrap();
 		assert!(tx.is_inherent());
 		if let RuntimeCall::Example(crate::Call::submit_price_unsigned_with_signed_payload {
 			price_payload: body,
 			signature,
-		}) = tx.function
+		}) = tx.expect_as_full().call.clone()
 		{
 			assert_eq!(body, price_payload);
 
@@ -381,10 +384,10 @@ fn should_submit_raw_unsigned_transaction_on_chain() {
 		// then
 		let tx = pool_state.write().transactions.pop().unwrap();
 		assert!(pool_state.read().transactions.is_empty());
-		let tx = Extrinsic::decode(&mut &*tx).unwrap();
+		let mut tx = Extrinsic::decode(&mut &*tx).unwrap();
 		assert!(tx.is_inherent());
 		assert_eq!(
-			tx.function,
+			tx.expect_as_full().call.clone(),
 			RuntimeCall::Example(crate::Call::submit_price_unsigned {
 				block_number: 1,
 				price: 15523

substrate/frame/im-online/src/tests.rs

@@ -26,7 +26,7 @@ use sp_core::offchain::{
 	testing::{TestOffchainExt, TestTransactionPoolExt},
 	OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,
 };
-use sp_runtime::testing::UintAuthorityId;
+use sp_runtime::{testing::UintAuthorityId, traits::LazyExtrinsic};
 
 #[test]
 fn test_unresponsiveness_slash_fraction() {
@@ -224,16 +224,16 @@ fn should_generate_heartbeats() {
 		assert_eq!(state.read().transactions.len(), 2);
 
 		// check stuff about the transaction.
-		let ex: Extrinsic = Decode::decode(&mut &*transaction).unwrap();
-		let heartbeat = match ex.function {
+		let mut ex: Extrinsic = Decode::decode(&mut &*transaction).unwrap();
+		let heartbeat = match ex.expect_as_full().call {
 			crate::mock::RuntimeCall::ImOnline(crate::Call::heartbeat { heartbeat, .. }) =>
 				heartbeat,
 			e => panic!("Unexpected call: {:?}", e),
 		};
 
 		assert_eq!(
 			heartbeat,
-			Heartbeat {
+			&Heartbeat {
 				block_number: block,
 				session_index: 2,
 				authority_index: 2,
@@ -338,16 +338,16 @@ fn should_not_send_a_report_if_already_online() {
 		// All validators have `0` as their session key, but we should only produce 1 heartbeat.
 		assert_eq!(pool_state.read().transactions.len(), 0);
 		// check stuff about the transaction.
-		let ex: Extrinsic = Decode::decode(&mut &*transaction).unwrap();
-		let heartbeat = match ex.function {
+		let mut ex: Extrinsic = Decode::decode(&mut &*transaction).unwrap();
+		let heartbeat = match ex.expect_as_full().call {
 			crate::mock::RuntimeCall::ImOnline(crate::Call::heartbeat { heartbeat, .. }) =>
 				heartbeat,
 			e => panic!("Unexpected call: {:?}", e),
 		};
 
 		assert_eq!(
 			heartbeat,
-			Heartbeat { block_number: 4, session_index: 2, authority_index: 0, validators_len: 3 }
+			&Heartbeat { block_number: 4, session_index: 2, authority_index: 0, validators_len: 3 }
 		);
 	});
 }

substrate/frame/support/src/traits/misc.rs

@@ -921,7 +921,7 @@ impl<Address, Call, Signature, Extra> InherentBuilder
 	for sp_runtime::generic::UncheckedExtrinsic<Address, Call, Signature, Extra>
 where
 	Address: TypeInfo,
-	Call: Clone + DecodeWithMemTracking + TypeInfo,
+	Call: DecodeWithMemTracking + TypeInfo,
 	Signature: TypeInfo,
 	Extra: TypeInfo,
 {
@@ -950,7 +950,7 @@ impl<Address, Call, Signature, Extension> SignedTransactionBuilder
 	for sp_runtime::generic::UncheckedExtrinsic<Address, Call, Signature, Extension>
 where
 	Address: TypeInfo,
-	Call: Clone + DecodeWithMemTracking + TypeInfo,
+	Call: DecodeWithMemTracking + TypeInfo,
 	Signature: TypeInfo,
 	Extension: TypeInfo,
 {