keep both public key object and their continous serialization in pair…

…ed crypto object in favor of avoiding copy

substrate/primitives/core/src/paired_crypto.rs

@@ -37,7 +37,7 @@ use sp_std::{convert::TryFrom, marker::PhantomData, ops::Deref};
 
 /// ECDSA and BLS-377 specialized types
 pub mod ecdsa_n_bls377 {
-	use crate::crypto::{CryptoTypeId};
+    use crate::crypto::{CryptoTypeId};
     use crate::{ecdsa, ed25519};
 
 	/// An identifier used to match public keys against BLS12-377 keys
@@ -47,7 +47,7 @@ pub mod ecdsa_n_bls377 {
 	#[cfg(feature = "full_crypto")]
 	//pub type Pair = super::Pair<ecdsa:Pair, bls377:Pair>;
 	/// BLS12-377 public key.
-	pub type Public = super::Public<ecdsa::Public, ed25519::Public, 32, 32>;
+	pub type Public = super::Public<ecdsa::Public, ed25519::Public, 64>;
 	// /// BLS12-377 signature.
 	//pub type Signature = super::Signature<ecdsa:Signature, bls377:Signature>;
 
@@ -64,61 +64,71 @@ pub mod ecdsa_n_bls377 {
 #[cfg(feature = "full_crypto")]
 //type Seed = [u8; SECRET_KEY_SERIALIZED_SIZE];
 
-pub trait PublicKeyBound: TraitPublic + sp_std::hash::Hash + ByteArray  {}
+pub trait PublicKeyBound: TraitPublic + sp_std::hash::Hash + ByteArray + for<'a> TryFrom<&'a[u8]>  {}
 /// A public key.
 #[derive(Clone, Encode, Decode, MaxEncodedLen, TypeInfo, PartialEq, Eq, PartialOrd, Ord)]
 #[scale_info(skip_type_params(T))]
-pub struct Public<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_LEN: usize, const RIGHT_LEN: usize,> (LeftPublic, RightPublic);
+pub struct Public<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_PLUS_RIGHT_LEN: usize,> {
+    left: LeftPublic,
+    right: RightPublic,
+    inner: [u8; LEFT_PLUS_RIGHT_LEN],
+}
+
+// We essentially could implement this instead of storing left and right but we are going to end up copying left and right.
+// impl<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_PLUS_RIGHT_LEN: usize>  Public<LeftPublic, RightPublic, LEFT_PLUS_RIGHT_LEN> {
+//     inline fn left<'a>(&self)-> &'a LeftPublic {
+// 	&LeftPublic::try_from(&self.inner[0..LeftPublic::LEN]).unwrap()
+//     }
+
+//     fn right<'a>(&self)-> &'a RightPublic {
+// 	&RightPublic::try_from(&self.inner[LeftPublic::LEN..LEFT_PLUS_RIGHT_LEN]).unwrap()
+//     }
+
+
+// }
 
 #[cfg(feature = "full_crypto")]
-impl<LeftPublic: PublicKeyBound + UncheckedFrom<[u8; LEFT_LEN]>, RightPublic: PublicKeyBound + UncheckedFrom<[u8; RIGHT_LEN]>, const LEFT_LEN: usize, const RIGHT_LEN: usize> sp_std::hash::Hash for Public<LeftPublic, RightPublic, LEFT_LEN, RIGHT_LEN> {
-  	fn hash<H: sp_std::hash::Hasher>(&self, state: &mut H) {
- 	    self.0.hash(state);
-	    self.1.hash(state);
+impl<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_PLUS_RIGHT_LEN: usize> sp_std::hash::Hash for Public<LeftPublic, RightPublic, LEFT_PLUS_RIGHT_LEN> {
+    fn hash<H: sp_std::hash::Hasher>(&self, state: &mut H) {
+ 	    self.left.hash(state);
+	    self.right.hash(state);
 	}
 }
 
-impl<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_LEN: usize, const RIGHT_LEN: usize> ByteArray  for Public<LeftPublic, RightPublic, LEFT_LEN, RIGHT_LEN> where for<'a>  Public<LeftPublic, RightPublic, LEFT_LEN, RIGHT_LEN>: TryFrom<&'a [u8], Error = ()> + AsRef<[u8]> + AsMut<[u8]>  {
-     const LEN: usize = LeftPublic::LEN + RightPublic::LEN;
+impl<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_PLUS_RIGHT_LEN: usize> ByteArray  for Public<LeftPublic, RightPublic, LEFT_PLUS_RIGHT_LEN>   {
+     const LEN: usize = LEFT_PLUS_RIGHT_LEN;
 }
 
-impl<'a,LeftPublic: PublicKeyBound + UncheckedFrom<[u8; LEFT_LEN]>, RightPublic: PublicKeyBound + UncheckedFrom<[u8; RIGHT_LEN]>, const LEFT_LEN: usize, const RIGHT_LEN: usize>  TryFrom<&'a[u8]> for Public<LeftPublic, RightPublic, LEFT_LEN, RIGHT_LEN> {
-    type Error = ();
+impl<'a,LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_PLUS_RIGHT_LEN: usize>  TryFrom<&'a[u8]> for Public<LeftPublic, RightPublic, LEFT_PLUS_RIGHT_LEN> {
+     type Error = ();
+
+     fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+  		if data.len() != 	LEFT_PLUS_RIGHT_LEN {
+ 			return Err(())
+ 		}
+ 	 let mut left : LeftPublic = data[0..LeftPublic::LEN].try_into().unwrap();
+	 let mut right : RightPublic = data[LeftPublic::LEN..LEFT_PLUS_RIGHT_LEN].try_into().unwrap();
 
-    fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
- 		if data.len() != 	LEFT_LEN + RIGHT_LEN {
-			return Err(())
-		}
+	 let mut inner = [0u8; LEFT_PLUS_RIGHT_LEN];
+	 Ok(Public { left, right, inner })
+
+     }
+}
 
- 		let mut r0 = [0u8;  LEFT_LEN];
- 		let mut r1 = [0u8; RIGHT_LEN];
-		r0.copy_from_slice(&data[0..LEFT_LEN]);  
- 		r1.copy_from_slice(&data[LEFT_LEN..RIGHT_LEN]);
-		Ok(Self(LeftPublic::unchecked_from(r0),RightPublic::unchecked_from(r1)))
+impl<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_PLUS_RIGHT_LEN: usize> AsMut<[u8]> for Public<LeftPublic, RightPublic, LEFT_PLUS_RIGHT_LEN> {
+    fn as_mut(&mut self) -> &mut [u8] {
+	&mut self.inner[..]
     }
 }
 
-// impl<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_LEN: usize, const RIGHT_LEN: usize> AsMut<[u8]> for Public<LeftPublic, RightPublic, LEFT_LEN, RIGHT_LEN> {
-//  	fn as_mut(&mut self) -> &mut [u8] {
-//  	 &mut [self.0.as_mut(), self.1.as_mut()].concat()
-//  	}
-// }
-
-// impl<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_LEN: usize, const RIGHT_LEN: usize, const RIGHT_PLUS_LEFT_LEN: usize> AsRef<[u8; RIGHT_PLUS_LEFT_LEN]> for Public<LeftPublic, RightPublic, LEFT_LEN, RIGHT_LEN> where for<'a>  Public<LeftPublic, RightPublic, LEFT_LEN, RIGHT_LEN>: TryFrom<&'a [u8], Error = ()> {
-//     fn as_ref(&self) -> &[u8; RIGHT_PLUS_LEFT_LEN] {
-// 	let mut r = [0u8; RIGHT_PLUS_LEFT_LEN];
-// 	r.copy_from_slice(self.0.as_ref());
-// 	r[LeftPublic::LEN..].copy_from_slice(self.1.as_ref());
-// 	&r
-//     }
-// }
+impl<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_PLUS_RIGHT_LEN: usize> AsRef<[u8; LEFT_PLUS_RIGHT_LEN]> for Public<LeftPublic, RightPublic, LEFT_PLUS_RIGHT_LEN>  {
+    fn as_ref(&self) -> &[u8; LEFT_PLUS_RIGHT_LEN] {
+		&self.inner
+    }
+}
 
-// impl<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_LEN: usize, const RIGHT_LEN: usize,> AsRef<[u8]> for Public<LeftPublic, RightPublic, LEFT_LEN, RIGHT_LEN> {
-//     fn as_ref(&self) -> &[u8] {
-// 	//let mut r : Vec<u8> = vec![0u8; LEFT_LEN + RIGHT_LEN];
-// 	//r.copy_from_slice(self.0.as_ref(), LeftPublic::LEN);
-// 	//r[LeftPublic::LEN..].copy_from_slice(self.1.as_ref(), RightPublic::LEN);
-// 	let mut r :Vec<u8> = [self.0.as_ref(), self.1.as_ref()].concat();
-// 	&r[..]
-//     }
-// }
+impl<LeftPublic: PublicKeyBound, RightPublic: PublicKeyBound, const LEFT_PLUS_RIGHT_LEN: usize,> AsRef<[u8]> for Public<LeftPublic, RightPublic, LEFT_PLUS_RIGHT_LEN> {
+    fn as_ref(&self) -> &[u8] {
+	&self.inner[..]
+    }
+}