Finality Verifier Pallet (#629)

* Add skeleton for `pallet-finality-verifier`

* Sketch out implementation for importing finality proofs

* Get pallet compiling

* Introduce skeleton for mock runtime

* Start using real Grandpa types in finality pallet

* Redefine types in header chain primitives crate

* Implement HeaderChain for Substrate bridge pallet

* Plug Substrate Bridge Pallet into verifier mock

* Fix compilation of `header-chain` primitives

* Start writing to base pallet storage

* Add first "cross-pallet" test

* Move keyring primitives used in tests to shared crate

* Stop pulling `std` deps into `no_std` builds

* Revert "Stop pulling `std` deps into `no_std` builds"

This reverts commit f74dd660652f98b7336936d1534a4e63cc9169a5.

* Revert "Move keyring primitives used in tests to shared crate"

This reverts commit b774fa730b2cdc40545afff308a66b0840266001.

* Use new SS58Prefix type in mock

* Start using `bp-test-utils` in finality pallet

* Start using real justification code

* Get a test working with real justification verification

* Add basic tests for invalid proofs

* Get rid of AncestryProof config type

* Add error types to transaction outcome

* Bound number of headers allowed in a single ancestry proof

* Disallow invalid authority sets

* Remove unused items

* Add some documentation

* Get rid of Clippy warnings

* Rename BaseHeaderChain to TransactionVerifier

* Remove unused code

* Make dummy trait implementations more generic

* Fix more Clippy complaints

* Update tests to use fix for duplicate headers

* Fix benchmarking compilation

* Rename TransactionVerifier to InclusionProofVerifier

bridges/primitives/header-chain/src/lib.rs

@@ -19,10 +19,16 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use codec::{Codec, EncodeLike};
+use codec::{Codec, Decode, Encode, EncodeLike};
 use core::clone::Clone;
 use core::cmp::Eq;
+use core::default::Default;
 use core::fmt::Debug;
+#[cfg(feature = "std")]
+use serde::{Deserialize, Serialize};
+use sp_finality_grandpa::{AuthorityList, SetId};
+use sp_runtime::RuntimeDebug;
+use sp_std::prelude::Vec;
 
 pub mod justification;
 
@@ -32,8 +38,25 @@ pub mod justification;
 pub trait Parameter: Codec + EncodeLike + Clone + Eq + Debug {}
 impl<T> Parameter for T where T: Codec + EncodeLike + Clone + Eq + Debug {}
 
-/// A base trait for pallets which want to keep track of a full set of headers from a bridged chain.
-pub trait BaseHeaderChain {
+/// A GRANDPA Authority List and ID.
+#[derive(Default, Encode, Decode, RuntimeDebug, PartialEq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct AuthoritySet {
+	/// List of GRANDPA authorities for the current round.
+	pub authorities: AuthorityList,
+	/// Monotonic identifier of the current GRANDPA authority set.
+	pub set_id: SetId,
+}
+
+impl AuthoritySet {
+	/// Create a new GRANDPA Authority Set.
+	pub fn new(authorities: AuthorityList, set_id: SetId) -> Self {
+		Self { authorities, set_id }
+	}
+}
+
+/// base trait for verifying transaction inclusion proofs.
+pub trait InclusionProofVerifier {
 	/// Transaction type.
 	type Transaction: Parameter;
 	/// Transaction inclusion proof type.
@@ -44,3 +67,54 @@ pub trait BaseHeaderChain {
 	/// Returns Some(transaction) if proof is valid and None otherwise.
 	fn verify_transaction_inclusion_proof(proof: &Self::TransactionInclusionProof) -> Option<Self::Transaction>;
 }
+
+/// A base trait for pallets which want to keep track of a full set of headers from a bridged chain.
+pub trait HeaderChain<H> {
+	/// Get the best finalized header known to the header chain.
+	fn best_finalized() -> H;
+
+	/// Get the best authority set known to the header chain.
+	fn authority_set() -> AuthoritySet;
+
+	/// Write the given header to the underlying pallet storage.
+	#[allow(clippy::result_unit_err)]
+	fn import_header(header: H) -> Result<(), ()>;
+
+	/// Submit a valid finality proof for the given header to the underlying pallet storage.
+	///
+	/// This will finalize the given header and enact any authority set changes if required.
+	#[allow(clippy::result_unit_err)]
+	fn import_finality_proof(header: H, finality_proof: Vec<u8>) -> Result<(), ()>;
+}
+
+impl<H: Default> HeaderChain<H> for () {
+	fn best_finalized() -> H {
+		H::default()
+	}
+
+	fn authority_set() -> AuthoritySet {
+		AuthoritySet::default()
+	}
+
+	#[allow(clippy::result_unit_err)]
+	fn import_header(_header: H) -> Result<(), ()> {
+		Ok(())
+	}
+
+	#[allow(clippy::result_unit_err)]
+	fn import_finality_proof(_header: H, _finality_proof: Vec<u8>) -> Result<(), ()> {
+		Ok(())
+	}
+}
+
+/// A trait for checking if a given child header is a direct decendant of an ancestor.
+pub trait AncestryChecker<H, P> {
+	/// Is the child header a decendant of the ancestor header?
+	fn are_ancestors(ancestor: &H, child: &H, proof: &P) -> bool;
+}
+
+impl<H, P> AncestryChecker<H, P> for () {
+	fn are_ancestors(_ancestor: &H, _child: &H, _proof: &P) -> bool {
+		true
+	}
+}