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

Cargo.toml

@@ -321,3 +321,15 @@ inherits = "release"
 lto = "fat"
 # https://doc.rust-lang.org/rustc/codegen-options/index.html#codegen-units
 codegen-units = 1
+
+[patch.crates-io]
+bls-like = {git = "https://github.com/w3f/bls", branch = "skalman-hash-to-curve-wb"}
+# ark-ec = { git = "https://github.com/w3f/arkworks-algebra", branch = 'master'}
+# ark-ff = { git = "https://github.com/w3f/arkworks-algebra", branch = 'master'}
+# ark-std = { git = "https://github.com/arkworks-rs/std"}
+# ark-serialize = { git = "https://github.com/w3f/arkworks-algebra", branch = 'master'}
+# ark-serialize-derive = { git = "https://github.com/w3f/arkworks-algebra", branch = 'master'}
+# ark-bls12-381 = { git = "https://github.com/w3f/arkworks-curves", branch = 'skalman-bls12-377-wb-hash2curve'}
+# ark-bls12-377 = { git = "https://github.com/w3f/arkworks-curves", branch = 'skalman-bls12-377-wb-hash2curve'}
+
+# primitive-types = { git = "https://github.com/drskalman/parity-common"}

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;
+	}
 }