Make BEEFY client able to generate either ECDSA or (ECDSA,BLS) Finality proof.

Cargo.toml

@@ -321,3 +321,5 @@ inherits = "release"
 lto = "fat"
 # https://doc.rust-lang.org/rustc/codegen-options/index.html#codegen-units
 codegen-units = 1
+
+[patch.crates-io]

client/beefy/Cargo.toml

@@ -48,3 +48,4 @@ sp-finality-grandpa = { version = "4.0.0-dev", path = "../../primitives/finality
 sp-keyring = { version = "7.0.0", path = "../../primitives/keyring" }
 sp-tracing = { version = "6.0.0", path = "../../primitives/tracing" }
 substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+smart-default = "0.6.0"

client/beefy/src/aux_schema.rs

@@ -24,6 +24,7 @@ use log::{info, trace};
 use sc_client_api::{backend::AuxStore, Backend};
 use sp_blockchain::{Error as ClientError, Result as ClientResult};
 use sp_runtime::traits::Block as BlockT;
+use std::fmt::Debug;
 
 const VERSION_KEY: &[u8] = b"beefy_auxschema_version";
 const WORKER_STATE: &[u8] = b"beefy_voter_state";
@@ -36,15 +37,20 @@ pub(crate) fn write_current_version<B: AuxStore>(backend: &B) -> ClientResult<()
 }
 
 /// Write voter state.
-pub(crate) fn write_voter_state<Block: BlockT, B: AuxStore>(
+pub(crate) fn write_voter_state<
+	Block: BlockT,
+	B: AuxStore,
+	AuthId: Encode + Decode + Debug + Clone + Ord + Sync + Send + std::hash::Hash,
+	TSignature: Encode + Decode + Debug + Clone + Sync + Send,
+>(
 	backend: &B,
-	state: &PersistedState<Block>,
+	state: &PersistedState<Block, AuthId, TSignature>,
 ) -> ClientResult<()> {
 	trace!(target: LOG_TARGET, "🥩 persisting {:?}", state);
 	backend.insert_aux(&[(WORKER_STATE, state.encode().as_slice())], &[])
 }
 
-fn load_decode<B: AuxStore, T: Decode>(backend: &B, key: &[u8]) -> ClientResult<Option<T>> {
+fn load_decode<BE: AuxStore, T: Decode>(backend: &BE, key: &[u8]) -> ClientResult<Option<T>> {
 	match backend.get_aux(key)? {
 		None => Ok(None),
 		Some(t) => T::decode(&mut &t[..])
@@ -54,16 +60,21 @@ fn load_decode<B: AuxStore, T: Decode>(backend: &B, key: &[u8]) -> ClientResult<
 }
 
 /// Load or initialize persistent data from backend.
-pub(crate) fn load_persistent<B, BE>(backend: &BE) -> ClientResult<Option<PersistedState<B>>>
+pub(crate) fn load_persistent<B, BE, AuthId, TSignature>(
+	backend: &BE,
+) -> ClientResult<Option<PersistedState<B, AuthId, TSignature>>>
 where
 	B: BlockT,
 	BE: Backend<B>,
+	AuthId: Encode + Decode + Debug + Clone + Ord + Sync + Send + std::hash::Hash,
+	TSignature: Encode + Decode + Debug + Clone + Sync + Send,
 {
 	let version: Option<u32> = load_decode(backend, VERSION_KEY)?;
 
 	match version {
 		None => (),
-		Some(1) => return load_decode::<_, PersistedState<B>>(backend, WORKER_STATE),
+		Some(1) =>
+			return load_decode::<_, PersistedState<B, AuthId, TSignature>>(backend, WORKER_STATE),
 		other =>
 			return Err(ClientError::Backend(format!("Unsupported BEEFY DB version: {:?}", other))),
 	}
@@ -75,31 +86,70 @@ where
 #[cfg(test)]
 pub(crate) mod tests {
 	use super::*;
-	use crate::tests::BeefyTestNet;
+	use crate::tests::{BeefyAuthIdMaker, BeefyTestNet};
 	use sc_network_test::TestNetFactory;
 
+	use crate::keystore::{BeefyBLSnECDSAKeystore, BeefyECDSAKeystore, BeefyKeystore};
+
+	use beefy_primitives::{
+		bls_crypto::{Public as BLSPublic, Signature as BLSSignature},
+		ecdsa_crypto::{Public as ECDSAPublic, Signature as ECDSASignature},
+	};
+
 	// also used in tests.rs
 	pub fn verify_persisted_version<B: BlockT, BE: Backend<B>>(backend: &BE) -> bool {
 		let version: u32 = load_decode(backend, VERSION_KEY).unwrap().unwrap();
 		version == CURRENT_VERSION
 	}
 
-	#[tokio::test]
-	async fn should_load_persistent_sanity_checks() {
-		let mut net = BeefyTestNet::new(1);
+	//async fn should_load_persistent_sanity_checks()
+	async fn should_load_persistent_sanity_checks<AuthId, TSignature, TBeefyKeystore>()
+	where
+		TBeefyKeystore: BeefyKeystore<AuthId, TSignature, Public = AuthId> + 'static,
+		AuthId: Clone
+			+ Encode
+			+ Decode
+			+ Debug
+			+ Ord
+			+ Sync
+			+ Send
+			+ BeefyAuthIdMaker
+			+ std::hash::Hash
+			+ 'static,
+		TSignature: Encode + Decode + Debug + Clone + Sync + Send + std::cmp::PartialEq + 'static,
+	{
+		let mut net: BeefyTestNet<ECDSAPublic, ECDSASignature, BeefyECDSAKeystore> =
+			BeefyTestNet::new(1);
+		//let mut net: BeefyTestNet<AuthId, TSignature, TBeefyKeystore> = BeefyTestNet::new(1);
 		let backend = net.peer(0).client().as_backend();
 
 		// version not available in db -> None
-		assert_eq!(load_persistent(&*backend).unwrap(), None);
+		assert_eq!(load_persistent::<_, _, AuthId, TSignature>(&*backend).unwrap(), None);
 
 		// populate version in db
 		write_current_version(&*backend).unwrap();
 		// verify correct version is retrieved
 		assert_eq!(load_decode(&*backend, VERSION_KEY).unwrap(), Some(CURRENT_VERSION));
 
 		// version is available in db but state isn't -> None
-		assert_eq!(load_persistent(&*backend).unwrap(), None);
+		assert_eq!(load_persistent::<_, _, AuthId, TSignature>(&*backend).unwrap(), None);
 
 		// full `PersistedState` load is tested in `tests.rs`.
 	}
+
+	#[tokio::test]
+	async fn should_load_persistent_sanity_checks_with_ecdsa_signature() {
+		should_load_persistent_sanity_checks::<ECDSAPublic, ECDSASignature, BeefyECDSAKeystore>()
+			.await;
+	}
+
+	#[tokio::test]
+	async fn should_load_persistent_sanity_checks_with_ecdsa_n_bls_signature() {
+		should_load_persistent_sanity_checks::<
+			(ECDSAPublic, BLSPublic),
+			(ECDSASignature, BLSSignature),
+			BeefyBLSnECDSAKeystore,
+		>()
+		.await;
+	}
 }

client/beefy/src/communication/gossip.rs

@@ -18,6 +18,9 @@
 
 use std::{collections::BTreeMap, sync::Arc, time::Duration};
 
+use core::fmt::Debug;
+use std::marker::PhantomData;
+
 use sc_network::PeerId;
 use sc_network_gossip::{MessageIntent, ValidationResult, Validator, ValidatorContext};
 use sp_core::hashing::twox_64;
@@ -29,10 +32,7 @@ use parking_lot::{Mutex, RwLock};
 use wasm_timer::Instant;
 
 use crate::{communication::peers::KnownPeers, keystore::BeefyKeystore, LOG_TARGET};
-use beefy_primitives::{
-	crypto::{Public, Signature},
-	VoteMessage,
-};
+use beefy_primitives::VoteMessage;
 
 // Timeout for rebroadcasting messages.
 const REBROADCAST_AFTER: Duration = Duration::from_secs(60 * 5);
@@ -95,26 +95,40 @@ impl<B: Block> KnownVotes<B> {
 /// rejected/expired.
 ///
 ///All messaging is handled in a single BEEFY global topic.
-pub(crate) struct GossipValidator<B>
+pub(crate) struct GossipValidator<B, AuthId, TSignature, BKS>
 where
 	B: Block,
+	BKS: BeefyKeystore<AuthId, TSignature, Public = AuthId>,
+	AuthId: Encode + Decode + Debug + Clone + Ord + Sync + Send,
+	TSignature: Encode + Decode + Debug + Clone + Sync + Send,
 {
 	topic: B::Hash,
 	known_votes: RwLock<KnownVotes<B>>,
 	next_rebroadcast: Mutex<Instant>,
 	known_peers: Arc<Mutex<KnownPeers<B>>>,
+	_keystore: PhantomData<BKS>,
+	_auth_id: PhantomData<AuthId>,
+	_signature: PhantomData<TSignature>,
 }
 
-impl<B> GossipValidator<B>
+impl<B, AuthId, TSignature, BKS> GossipValidator<B, AuthId, TSignature, BKS>
 where
 	B: Block,
+	BKS: BeefyKeystore<AuthId, TSignature, Public = AuthId>,
+	AuthId: Encode + Decode + Debug + Clone + Ord + Sync + Send,
+	TSignature: Encode + Decode + Debug + Clone + Sync + Send,
 {
-	pub fn new(known_peers: Arc<Mutex<KnownPeers<B>>>) -> GossipValidator<B> {
+	pub fn new(
+		known_peers: Arc<Mutex<KnownPeers<B>>>,
+	) -> GossipValidator<B, AuthId, TSignature, BKS> {
 		GossipValidator {
 			topic: topic::<B>(),
 			known_votes: RwLock::new(KnownVotes::new()),
 			next_rebroadcast: Mutex::new(Instant::now() + REBROADCAST_AFTER),
 			known_peers,
+			_keystore: PhantomData,
+			_auth_id: PhantomData,
+			_signature: PhantomData,
 		}
 	}
 
@@ -135,9 +149,12 @@ where
 	}
 }
 
-impl<B> Validator<B> for GossipValidator<B>
+impl<B, AuthId, TSignature, BKS> Validator<B> for GossipValidator<B, AuthId, TSignature, BKS>
 where
 	B: Block,
+	BKS: BeefyKeystore<AuthId, TSignature, Public = AuthId>,
+	AuthId: Encode + Decode + Debug + Clone + Ord + Sync + Send,
+	TSignature: Encode + Decode + Debug + Clone + Sync + Send,
 {
 	fn peer_disconnected(&self, _context: &mut dyn ValidatorContext<B>, who: &PeerId) {
 		self.known_peers.lock().remove(who);
@@ -149,7 +166,7 @@ where
 		sender: &PeerId,
 		mut data: &[u8],
 	) -> ValidationResult<B::Hash> {
-		if let Ok(msg) = VoteMessage::<NumberFor<B>, Public, Signature>::decode(&mut data) {
+		if let Ok(msg) = VoteMessage::<NumberFor<B>, AuthId, TSignature>::decode(&mut data) {
 			let msg_hash = twox_64(data);
 			let round = msg.commitment.block_number;
 
@@ -168,7 +185,7 @@ where
 				}
 			}
 
-			if BeefyKeystore::verify(&msg.id, &msg.signature, &msg.commitment.encode()) {
+			if BKS::verify(&msg.id, &msg.signature, &msg.commitment.encode()) {
 				self.known_votes.write().add_known(&round, msg_hash);
 				self.known_peers.lock().note_vote_for(*sender, round);
 				return ValidationResult::ProcessAndKeep(self.topic)
@@ -187,7 +204,7 @@ where
 	fn message_expired<'a>(&'a self) -> Box<dyn FnMut(B::Hash, &[u8]) -> bool + 'a> {
 		let known_votes = self.known_votes.read();
 		Box::new(move |_topic, mut data| {
-			let msg = match VoteMessage::<NumberFor<B>, Public, Signature>::decode(&mut data) {
+			let msg = match VoteMessage::<NumberFor<B>, AuthId, TSignature>::decode(&mut data) {
 				Ok(vote) => vote,
 				Err(_) => return true,
 			};
@@ -221,7 +238,7 @@ where
 				return do_rebroadcast
 			}
 
-			let msg = match VoteMessage::<NumberFor<B>, Public, Signature>::decode(&mut data) {
+			let msg = match VoteMessage::<NumberFor<B>, AuthId, TSignature>::decode(&mut data) {
 				Ok(vote) => vote,
 				Err(_) => return false,
 			};
@@ -242,9 +259,12 @@ mod tests {
 	use sc_network_test::Block;
 	use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
 
-	use crate::keystore::{tests::Keyring, BeefyKeystore};
+	use crate::keystore::{
+		tests::{GenericKeyring, Keyring},
+		BeefyECDSAKeystore, BeefyKeystore,
+	};
 	use beefy_primitives::{
-		crypto::Signature, known_payloads, Commitment, MmrRootHash, Payload, VoteMessage, KEY_TYPE,
+		ecdsa_crypto, known_payloads, Commitment, MmrRootHash, Payload, VoteMessage, KEY_TYPE,
 	};
 
 	use super::*;
@@ -279,7 +299,12 @@ mod tests {
 
 	#[test]
 	fn note_and_drop_round_works() {
-		let gv = GossipValidator::<Block>::new(Arc::new(Mutex::new(KnownPeers::new())));
+		let gv = GossipValidator::<
+			Block,
+			ecdsa_crypto::AuthorityId,
+			ecdsa_crypto::Signature,
+			BeefyECDSAKeystore,
+		>::new(Arc::new(Mutex::new(KnownPeers::new())));
 
 		gv.note_round(1u64);
 
@@ -306,7 +331,12 @@ mod tests {
 
 	#[test]
 	fn note_same_round_twice() {
-		let gv = GossipValidator::<Block>::new(Arc::new(Mutex::new(KnownPeers::new())));
+		let gv = GossipValidator::<
+			Block,
+			ecdsa_crypto::AuthorityId,
+			ecdsa_crypto::Signature,
+			BeefyECDSAKeystore,
+		>::new(Arc::new(Mutex::new(KnownPeers::new())));
 
 		gv.note_round(3u64);
 		gv.note_round(7u64);
@@ -345,28 +375,53 @@ mod tests {
 		}
 	}
 
-	fn sign_commitment<BN: Encode>(who: &Keyring, commitment: &Commitment<BN>) -> Signature {
+	fn sign_commitment<BN: Encode>(
+		who: &Keyring,
+		commitment: &Commitment<BN>,
+	) -> ecdsa_crypto::Signature {
 		let store: SyncCryptoStorePtr = std::sync::Arc::new(LocalKeystore::in_memory());
-		SyncCryptoStore::ecdsa_generate_new(&*store, KEY_TYPE, Some(&who.to_seed())).unwrap();
-		let beefy_keystore: BeefyKeystore = Some(store).into();
-
-		beefy_keystore.sign(&who.public(), &commitment.encode()).unwrap()
+		SyncCryptoStore::ecdsa_generate_new(
+			&*store,
+			KEY_TYPE,
+			Some(&<Keyring as GenericKeyring<ecdsa_crypto::Pair>>::to_seed(*who)),
+		)
+		.unwrap();
+
+		let beefy_keystore = BeefyECDSAKeystore::new(store);
+
+		beefy_keystore
+			.sign(
+				&<Keyring as GenericKeyring<ecdsa_crypto::Pair>>::public(*who),
+				&commitment.encode(),
+			)
+			.unwrap()
 	}
 
-	fn dummy_vote(block_number: u64) -> VoteMessage<u64, Public, Signature> {
+	fn dummy_vote(
+		block_number: u64,
+	) -> VoteMessage<u64, ecdsa_crypto::Public, ecdsa_crypto::Signature> {
 		let payload = Payload::from_single_entry(
 			known_payloads::MMR_ROOT_ID,
 			MmrRootHash::default().encode(),
 		);
 		let commitment = Commitment { payload, block_number, validator_set_id: 0 };
 		let signature = sign_commitment(&Keyring::Alice, &commitment);
 
-		VoteMessage { commitment, id: Keyring::Alice.public(), signature }
+		VoteMessage {
+			commitment,
+			id: <Keyring as GenericKeyring<ecdsa_crypto::Pair>>::public(Keyring::Alice),
+			signature,
+		}
 	}
 
 	#[test]
 	fn should_avoid_verifying_signatures_twice() {
-		let gv = GossipValidator::<Block>::new(Arc::new(Mutex::new(KnownPeers::new())));
+		let gv = GossipValidator::<
+			Block,
+			ecdsa_crypto::AuthorityId,
+			ecdsa_crypto::Signature,
+			BeefyECDSAKeystore,
+		>::new(Arc::new(Mutex::new(KnownPeers::new())));
 		let sender = sc_network::PeerId::random();
 		let mut context = TestContext;
 
@@ -402,7 +457,12 @@ mod tests {
 
 	#[test]
 	fn messages_allowed_and_expired() {
-		let gv = GossipValidator::<Block>::new(Arc::new(Mutex::new(KnownPeers::new())));
+		let gv = GossipValidator::<
+			Block,
+			ecdsa_crypto::AuthorityId,
+			ecdsa_crypto::Signature,
+			BeefyECDSAKeystore,
+		>::new(Arc::new(Mutex::new(KnownPeers::new())));
 		let sender = sc_network::PeerId::random();
 		let topic = Default::default();
 		let intent = MessageIntent::Broadcast;
@@ -445,7 +505,12 @@ mod tests {
 
 	#[test]
 	fn messages_rebroadcast() {
-		let gv = GossipValidator::<Block>::new(Arc::new(Mutex::new(KnownPeers::new())));
+		let gv = GossipValidator::<
+			Block,
+			ecdsa_crypto::AuthorityId,
+			ecdsa_crypto::Signature,
+			BeefyECDSAKeystore,
+		>::new(Arc::new(Mutex::new(KnownPeers::new())));
 		let sender = sc_network::PeerId::random();
 		let topic = Default::default();