adding bandersnatch host function and application crypto impls

substrate/primitives/application-crypto/src/bandersnatch.rs

@@ -21,7 +21,10 @@ use crate::{KeyTypeId, RuntimePublic};
 use alloc::vec::Vec;
 pub use sp_core::bandersnatch::*;
 
-use sp_core::crypto::ProofOfPossessionVerifier;
+use sp_core::{
+	crypto::{ProofOfPossessionVerifier, POP_CONTEXT_TAG},
+	Pair as TraitPair,
+};
 
 mod app {
 	crate::app_crypto!(super, sp_core::testing::BANDERSNATCH);
@@ -43,19 +46,22 @@ impl RuntimePublic for Public {
 		sp_io::crypto::bandersnatch_generate(key_type, seed)
 	}
 
-	/// Dummy implementation. Returns `None`.
-	fn sign<M: AsRef<[u8]>>(&self, _key_type: KeyTypeId, _msg: &M) -> Option<Self::Signature> {
-		None
+	fn sign<M: AsRef<[u8]>>(&self, key_type: KeyTypeId, msg: &M) -> Option<Self::Signature> {
+		sp_io::crypto::bandersnatch_sign(key_type, self, msg.as_ref())
 	}
 
 	/// Dummy implementation. Returns `false`.
-	fn verify<M: AsRef<[u8]>>(&self, _msg: &M, _signature: &Self::Signature) -> bool {
-		false
+	fn verify<M: AsRef<[u8]>>(&self, msg: &M, signature: &Self::Signature) -> bool {
+		let sig = AppSignature::from(signature.clone());
+		let pub_key = AppPublic::from(self.clone());
+		AppPair::verify(&sig, msg.as_ref(), &pub_key)
 	}
 
 	/// Dummy implementation. Returns 'None'.
-	fn generate_pop(&mut self, _key_type: KeyTypeId) -> Option<Self::Signature> {
-		None
+	fn generate_pop(&mut self, key_type: KeyTypeId) -> Option<Self::Signature> {
+		let pub_key_as_bytes = self.to_raw_vec();
+		let pop_statement = [POP_CONTEXT_TAG, pub_key_as_bytes.as_slice()].concat();
+		sp_io::crypto::bandersnatch_sign(key_type, self, pop_statement.as_slice())
 	}
 
 	fn verify_pop(&self, pop: &Self::Signature) -> bool {

substrate/primitives/core/src/bandersnatch.rs

@@ -23,11 +23,9 @@
 #[cfg(feature = "full_crypto")]
 use crate::crypto::VrfSecret;
 use crate::crypto::{
-	ByteArray, CryptoType, CryptoTypeId, DeriveError, DeriveJunction, Pair as TraitPair,
-	ProofOfPossessionGenerator, ProofOfPossessionVerifier, PublicBytes, SecretStringError,
-	SignatureBytes, UncheckedFrom, VrfPublic,
+	ByteArray, CryptoType, CryptoTypeId, DeriveError, DeriveJunction, NonAggregatable,
+	Pair as TraitPair, PublicBytes, SecretStringError, SignatureBytes, UncheckedFrom, VrfPublic,
 };
-use sp_crypto_pubkeycrypto_proc_macro::ProofOfPossession;
 
 use bandersnatch_vrfs::{CanonicalSerialize, SecretKey};
 use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
@@ -77,7 +75,7 @@ impl CryptoType for Signature {
 type Seed = [u8; SEED_SERIALIZED_SIZE];
 
 /// Bandersnatch secret key.
-#[derive(Clone, ProofOfPossession)]
+#[derive(Clone)]
 pub struct Pair {
 	secret: SecretKey,
 	seed: Seed,
@@ -169,6 +167,8 @@ impl CryptoType for Pair {
 	type Pair = Pair;
 }
 
+impl NonAggregatable for Pair {}
+
 /// Bandersnatch VRF types and operations.
 pub mod vrf {
 	use super::*;

substrate/primitives/io/src/lib.rs

@@ -1273,6 +1273,24 @@ pub trait Crypto {
 			.bandersnatch_generate_new(id, seed)
 			.expect("`bandernatch_generate` failed")
 	}
+
+	/// Sign the given `msg` with the `bandersnatch` key that corresponds to the given public key
+	/// and key type in the keystore.
+	///
+	/// Returns the signature.
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_sign(
+		&mut self,
+		id: KeyTypeId,
+		pub_key: &bandersnatch::Public,
+		msg: &[u8],
+	) -> Option<bandersnatch::Signature> {
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.bandersnatch_sign(id, pub_key, msg)
+			.ok()
+			.flatten()
+	}
 }
 
 /// Interface that provides functions for hashing with different algorithms.