Extrinsics root is calculated as part of block-building

substrate/runtime/executive/src/lib.rs

@@ -49,13 +49,7 @@ use runtime_io::Hashing;
 use runtime_support::StorageValue;
 use primitives::traits::{self, Header, Zero, One, Checkable, Applyable, CheckEqual, Executable, MakePayment};
 use codec::Slicable;
-
-/// Compute the extrinsics root of a list of extrinsics.
-pub fn extrinsics_root<H: Hashing, E: Slicable>(extrinsics: &[E]) -> H::Output {
-	let xts = extrinsics.iter().map(Slicable::encode).collect::<Vec<_>>();
-	let xts = xts.iter().map(Vec::as_slice).collect::<Vec<_>>();
-	H::enumerated_trie_root(&xts)
-}
+use system::extrinsics_root;
 
 pub struct Executive<
 	System,
@@ -103,7 +97,7 @@ impl<
 
 		// execute transactions
 		let (header, extrinsics) = block.deconstruct();
-		extrinsics.into_iter().for_each(Self::apply_extrinsic);
+		extrinsics.into_iter().for_each(Self::apply_extrinsic_inner);
 
 		// post-transactional book-keeping.
 		Finalisation::execute();
@@ -120,15 +114,26 @@ impl<
 	pub fn finalise_block() -> System::Header {
 		Finalisation::execute();
 
+		// setup extrinsics
+		<system::Module<System>>::derive_extrinsics();
+
 		let header = <system::Module<System>>::finalise();
 		Self::post_finalise(&header);
 
 		header
 	}
 
 	/// Apply outside of the block execution function.
-	/// This doesn't attempt to validate anything regarding the block.
+	/// This doesn't attempt to validate anything regarding the block, but it builds a list of uxt
+	/// hashes.
 	pub fn apply_extrinsic(uxt: Block::Extrinsic) {
+		<system::Module<System>>::note_extrinsic(uxt.encode());
+		Self::apply_extrinsic_inner(uxt);
+	}
+
+	/// Apply outside of the block execution function.
+	/// This doesn't attempt to validate anything regarding the block.
+	fn apply_extrinsic_inner(uxt: Block::Extrinsic) {
 		// Verify the signature is good.
 		let xt = match uxt.check() {
 			Ok(xt) => xt,

substrate/runtime/system/src/lib.rs

@@ -47,6 +47,13 @@ use codec::Slicable;
 #[cfg(any(feature = "std", test))]
 use runtime_io::{twox_128, TestExternalities};
 
+/// Compute the extrinsics root of a list of extrinsics.
+pub fn extrinsics_root<H: Hashing, E: codec::Slicable>(extrinsics: &[E]) -> H::Output {
+	let xts = extrinsics.iter().map(codec::Slicable::encode).collect::<Vec<_>>();
+	let xts = xts.iter().map(Vec::as_slice).collect::<Vec<_>>();
+	H::enumerated_trie_root(&xts)
+}
+
 pub trait Trait {
 	type Index: Parameter + Default + SimpleArithmetic + Copy;
 	type BlockNumber: Parameter + SimpleArithmetic + Default + Bounded + Copy;
@@ -68,6 +75,7 @@ decl_storage! {
 	pub BlockHash get(block_hash): b"sys:old" => required map [ T::BlockNumber => T::Hash ];
 
 	pub ExtrinsicIndex get(extrinsic_index): b"sys:xti" => required u32;
+	pub ExtrinsicData get(extrinsic_data): b"sys:xtd" => required map [ u32 => Vec<u8> ];
 	RandomSeed get(random_seed): b"sys:rnd" => required T::Hash;
 	// The current block number being processed. Set by `execute_block`.
 	Number get(block_number): b"sys:num" => required T::BlockNumber;
@@ -170,6 +178,19 @@ impl<T: Trait> Module<T> {
 	pub fn inc_account_index(who: &T::AccountId) {
 		<AccountIndex<T>>::insert(who, Self::account_index(who) + T::Index::one());
 	}
+
+	/// Note what the extrinsic data of the current extrinsic index is. If this is called, then
+	/// ensure `derive_extrinsics` is also called before block-building is completed.
+	pub fn note_extrinsic(encoded_xt: Vec<u8>) {
+		<ExtrinsicData<T>>::insert(Self::extrinsic_index(), encoded_xt);
+	}
+
+	/// Remove all extrinsics data and save the extrinsics trie root.
+	pub fn derive_extrinsics() {
+		let extrinsics = (0..Self::extrinsic_index()).map(<ExtrinsicData<T>>::take).collect::<Vec<_>>();
+		let xts_root = extrinsics_root::<T::Hashing, _>(&extrinsics);
+		<ExtrinsicsRoot<T>>::put(xts_root);
+	}
 }
 
 #[cfg(any(feature = "std", test))]