executive batching

frame/executive/src/lib.rs

@@ -232,22 +232,24 @@ where
 		assert!(header.extrinsics_root() == &xts_root, "Transaction trie root must be valid.");
 	}
 
-	fn register_dynamic_extensions() {
-	}
-
 	/// Actually execute all transitions for `block`.
 	pub fn execute_block(block: Block) {
 		Self::initialize_block(block.header());
 
 		// any initial checks
 		Self::initial_checks(&block);
 
-		Self::register_dynamic_extensions();
+		sp_io::extensions::start_verification_extension();
 
 		// execute extrinsics
 		let (header, extrinsics) = block.deconstruct();
 		Self::execute_extrinsics_with_book_keeping(extrinsics, *header.number());
 
+		if !sp_io::crypto::batch_verify() {
+			panic!("Signature verification failed.")
+		}
+		sp_io::extensions::drop_verification_extension();
+
 		// any final checks
 		Self::final_checks(&header);
 	}

primitives/runtime/src/generic/unchecked_extrinsic.rs

@@ -24,7 +24,8 @@ use crate::{
 		self, Member, MaybeDisplay, SignedExtension, Checkable, Extrinsic, ExtrinsicMetadata,
 		IdentifyAccount,
 	},
-	generic::CheckedExtrinsic, transaction_validity::{TransactionValidityError, InvalidTransaction},
+	generic::{CheckSignature, CheckedExtrinsic},
+	transaction_validity::{TransactionValidityError, InvalidTransaction},
 };
 
 const TRANSACTION_VERSION: u8 = 4;
@@ -131,7 +132,25 @@ where
 					return Err(InvalidTransaction::BadProof.into())
 				}
 
+<<<<<<< HEAD
 				let (function, extra, _) = raw_payload.deconstruct();
+=======
+				let (function, extra) = if let CheckSignature::No = check_signature {
+					(self.function, extra)
+				} else {
+					let raw_payload = SignedPayload::new(self.function, extra)?;
+
+					if !raw_payload.using_encoded(|payload| {
+						signature.batch_verify(payload, &signed).ok()
+					}) {
+						return Err(InvalidTransaction::BadProof.into())
+					}
+					let (function, extra, _) = raw_payload.deconstruct();
+
+					(function, extra)
+				};
+
+>>>>>>> executive batching
 				CheckedExtrinsic {
 					signed: Some((signed, extra)),
 					function,

primitives/runtime/src/traits.rs

@@ -83,6 +83,19 @@ pub enum BatchResult {
 	Immediate(bool),
 }
 
+impl BatchResult {
+	/// Is verification ok.
+	///
+	/// Returns true if verification is either produced immediate positive outcome or
+	/// is batched.
+	pub fn ok(&self) -> bool {
+		match self {
+			Self::Ok => true,
+			Self::Immediate(val) => *val,
+		}
+	}
+}
+
 /// Means of signature verification.
 pub trait Verify {
 	/// Type of the signer.
@@ -120,6 +133,11 @@ impl Verify for sp_core::sr25519::Signature {
 	fn verify<L: Lazy<[u8]>>(&self, mut msg: L, signer: &sp_core::sr25519::Public) -> bool {
 		sp_io::crypto::sr25519_verify(self, msg.get(), signer)
 	}
+
+	fn batch_verify<L: Lazy<[u8]>>(&self, mut msg: L, signer: &<Self::Signer as IdentifyAccount>::AccountId) -> BatchResult {
+		sp_io::crypto::batch_push_sr25519(self, msg.get(), signer);
+		BatchResult::Ok
+	}
 }
 
 impl Verify for sp_core::ecdsa::Signature {