GRANDPA finality proof draft (#1268)

* grandpa finality proof

* prove GrandpaApi::grandpa_authorities using parent block + some docs

* create justification when consensus data is changed

* generate justifications periodically

* test for ConsensusChanges

substrate/core/transaction-pool/graph/src/pool.rs

@@ -327,7 +327,7 @@ mod tests {
 		/// Verify extrinsic at given block.
 		fn validate_transaction(&self, at: &BlockId<Self::Block>, uxt: &ExtrinsicFor<Self>) -> Result<TransactionValidity, Self::Error> {
 			let block_number = self.block_id_to_number(at)?.unwrap();
-			let nonce = uxt.transfer.nonce;
+			let nonce = uxt.transfer().nonce;
 
 			if nonce < block_number {
 				Ok(TransactionValidity::Invalid)
@@ -359,15 +359,12 @@ mod tests {
 
 		/// Hash the extrinsic.
 		fn hash(&self, uxt: &ExtrinsicFor<Self>) -> Self::Hash {
-			(uxt.transfer.from.to_low_u64_be() << 5) + uxt.transfer.nonce
+			(uxt.transfer().from.to_low_u64_be() << 5) + uxt.transfer().nonce
 		}
 	}
 
 	fn uxt(transfer: Transfer) -> Extrinsic {
-		Extrinsic {
-			transfer,
-			signature: Default::default(),
-		}
+		Extrinsic::Transfer(transfer, Default::default())
 	}
 
 	fn pool() -> Pool<TestApi> {

substrate/core/transaction-pool/src/tests.rs

@@ -42,12 +42,12 @@ impl txpool::ChainApi for TestApi {
 
 	fn validate_transaction(&self, at: &BlockId<Self::Block>, uxt: &txpool::ExtrinsicFor<Self>) -> error::Result<TransactionValidity> {
 		let expected = index(at);
-		let requires = if expected == uxt.transfer.nonce {
+		let requires = if expected == uxt.transfer().nonce {
 			vec![]
 		} else {
-			vec![vec![uxt.transfer.nonce as u8 - 1]]
+			vec![vec![uxt.transfer().nonce as u8 - 1]]
 		};
-		let provides = vec![vec![uxt.transfer.nonce as u8]];
+		let provides = vec![vec![uxt.transfer().nonce as u8]];
 
 		Ok(TransactionValidity::Valid {
 			priority: 1,
@@ -93,10 +93,7 @@ fn uxt(who: Keyring, nonce: Index) -> Extrinsic {
 		amount: 1,
 	};
 	let signature = transfer.using_encoded(|e| who.sign(e));
-	Extrinsic {
-		transfer,
-		signature: signature.into(),
-	}
+	Extrinsic::Transfer(transfer, signature.into())
 }
 
 fn pool() -> Pool<TestApi> {
@@ -109,7 +106,7 @@ fn submission_should_work() {
 	assert_eq!(209, index(&BlockId::number(0)));
 	pool.submit_one(&BlockId::number(0), uxt(Alice, 209)).unwrap();
 
-	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer.nonce).collect();
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
 	assert_eq!(pending, vec![209]);
 }
 
@@ -119,7 +116,7 @@ fn multiple_submission_should_work() {
 	pool.submit_one(&BlockId::number(0), uxt(Alice, 209)).unwrap();
 	pool.submit_one(&BlockId::number(0), uxt(Alice, 210)).unwrap();
 
-	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer.nonce).collect();
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
 	assert_eq!(pending, vec![209, 210]);
 }
 
@@ -128,7 +125,7 @@ fn early_nonce_should_be_culled() {
 	let pool = pool();
 	pool.submit_one(&BlockId::number(0), uxt(Alice, 208)).unwrap();
 
-	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer.nonce).collect();
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
 	assert_eq!(pending, Vec::<Index>::new());
 }
 
@@ -137,11 +134,11 @@ fn late_nonce_should_be_queued() {
 	let pool = pool();
 
 	pool.submit_one(&BlockId::number(0), uxt(Alice, 210)).unwrap();
-	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer.nonce).collect();
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
 	assert_eq!(pending, Vec::<Index>::new());
 
 	pool.submit_one(&BlockId::number(0), uxt(Alice, 209)).unwrap();
-	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer.nonce).collect();
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
 	assert_eq!(pending, vec![209, 210]);
 }
 
@@ -151,12 +148,12 @@ fn prune_tags_should_work() {
 	pool.submit_one(&BlockId::number(0), uxt(Alice, 209)).unwrap();
 	pool.submit_one(&BlockId::number(0), uxt(Alice, 210)).unwrap();
 
-	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer.nonce).collect();
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
 	assert_eq!(pending, vec![209, 210]);
 
 	pool.prune_tags(&BlockId::number(1), vec![vec![209]]).unwrap();
 
-	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer.nonce).collect();
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
 	assert_eq!(pending, vec![210]);
 }
 
@@ -169,7 +166,7 @@ fn should_ban_invalid_transactions() {
 	pool.submit_one(&BlockId::number(0), uxt.clone()).unwrap_err();
 
 	// when
-	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer.nonce).collect();
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
 	assert_eq!(pending, Vec::<Index>::new());
 
 	// then