update cryptographic proof mechanisms

Author: snqre

app/node/src/identity.rs

@@ -2,138 +2,201 @@ use super::*;
 use ed25519_dalek::Signer as _;
 use ed25519::signature::Keypair as _;
 
-#[derive(Debug)]
-#[derive(Clone)]
-#[derive(PartialEq)]
-#[derive(Eq)]
-#[derive(derive_more::Deref)]
-#[derive(derive_more::DerefMut)]
-pub struct SignedVerified {
-	pk: PublicKey,
-	#[deref]
-	#[deref_mut]
-	content: Vec<u8>
+pub mod commitment {
+	
 }
 
-impl SignedVerified {
-	pub fn pk(&self) -> &PublicKey {
-		&self.pk
+pub mod multi_party {
+	use super::*;
+		
+	pub struct CompleteVerified(Vec<u8>);
+	
+	impl TryFrom<Partial> for CompleteVerified {
+		type Error = Box<dyn std::error::Error>;
+		
+		fn try_from(value: Partial) -> std::result::Result<Self, Self::Error> {
+			
+		}
 	}
 
-	pub fn content(&self) -> &[u8] {
-		&self.content
+	// all parties have signed
+	pub struct CompleteUnverified(Vec<u8>);
+	
+	pub struct CompleteVerified {
+		signers: Vec<PublicKey>,
+		content: Vec<u8>
 	}
 
-	pub fn unpack(self) -> (PublicKey, Unsigned) {
-		let mg: Unsigned = self.content.into();
-		(self.pk, mg)
+	#[derive(Debug)]
+	#[derive(Clone)]
+	#[derive(PartialEq)]
+	#[derive(Eq)]
+	pub struct Partial {
+		mg: Vec<u8>,
+		pk_to_sg: std::collections::HashMap<PublicKey, Signature>,
+		signers: Vec<PublicKey>
 	}
-}
-
-impl TryFrom<SignedUnverified> for SignedVerified {
-	type Error = Box<dyn std::error::Error>;
 
-	fn try_from(value: SignedUnverified) -> std::result::Result<Self, Self::Error> {
-		let (sg, pk, mg) = value.unpack();
-
-		sg.verify(&mg, &pk)?;
+	impl Partial {
+		pub fn sign(self, pk: PublicKey, sg: Signature) -> Result<Or<Self, CompleteVerified>> {
+			sg.verify(mg, &pk)?;
+			
+			self.pk_to_sg.insert(pk, sg);
+			Ok(Or::Lhs(self))
+		}
+	}
+	
+	impl TryFrom<Vec<u8>> for Partial {
+		type Error = Box<dyn std::error::Error>;
 
-		let Unsigned(content) = mg;
-		Ok(Self {
-			pk: pk.to_owned(),
-			content
-		})
+		fn try_from(value: Vec<u8>) -> std::result::Result<Self, Self::Error> {
+			
+		}
 	}
+	
+	pub struct Unsigned(Vec<u8>);
 }
 
-#[derive(Debug)]
-#[derive(Clone)]
-#[derive(PartialEq)]
-#[derive(Eq)]
-#[derive(serde::Serialize)]
-#[derive(serde::Deserialize)]
-#[derive(derive_more::Deref)]
-#[derive(derive_more::DerefMut)]
-#[serde(try_from = "Vec<u8>")]
-pub struct SignedUnverified(Vec<u8>);
-
-impl SignedUnverified {
-	pub fn verify(self) -> Result<SignedVerified> {
-		self.try_into()
-	}
-	
-	pub fn unpack(self) -> (Signature, PublicKey, Unsigned) {
-		let Self(mut bytes) = self;				
-		let mut mgpk: Vec<_> = bytes.split_off(64);
-		let mg: Vec<_> = mgpk.split_off(32);
-		let mg: Unsigned = mg.try_into().expect("unsigned content slice is guaranteed to be non-empty via constructors");
-		let pk: [_; _] = mgpk.as_slice().try_into().expect("public key state corruption; must equal 32 bytes");
-		let pk: PublicKey = pk.into();
-		let sg: [_; _] = bytes.as_slice().try_into().expect("signature state corruption; remaining bytes must equal 64; guaranteed via constructors");
-		let sg: Signature = sg.into();
-		(sg, pk, mg)
+pub mod single_party {
+	use super::*;
+	
+	#[derive(Debug)]
+	#[derive(Clone)]
+	#[derive(PartialEq)]
+	#[derive(Eq)]
+	#[derive(derive_more::Deref)]
+	#[derive(derive_more::DerefMut)]
+	pub struct SignedVerified {
+		pk: PublicKey,
+		#[deref]
+		#[deref_mut]
+		content: Vec<u8>
 	}
-}
-
-impl From<(&Unsigned, &SecretKey)> for SignedUnverified {
-	fn from(value: (&Unsigned, &SecretKey)) -> Self {
-		let (Unsigned(mg), SecretKey(sk)) = value;
-		let sk: ed25519_dalek::SigningKey = ed25519_dalek::SigningKey::from_bytes(&sk);
-		let pk: [_; _] = sk.verifying_key().to_bytes();
-		let sg: ed25519_dalek::Signature = sk.sign(&mg);
-		let sg: [_; _] = sg.to_bytes();
-		let capacity: usize = 64 + 32 + mg.len();
+	
+	impl SignedVerified {
+		pub fn pk(&self) -> &PublicKey {
+			&self.pk
+		}
 
-		let mut bytes: Vec<_> = Vec::with_capacity(capacity);
-		bytes.extend_from_slice(&sg);
-		bytes.extend_from_slice(&pk);
-		bytes.extend_from_slice(&mg);
+		pub fn content(&self) -> &[u8] {
+			&self.content
+		}
+	}
+	
+	impl Unpack<(PublicKey, Unsigned)> for SignedVerified {
+		fn unpack(self) -> (PublicKey, Unsigned) {
+			let mg: Unsigned = self.content.into();
+			(self.pk, mg)
+		}
+	}
+	
+	impl TryFrom<SignedUnverified> for SignedVerified {
+		type Error = Box<dyn std::error::Error>;
 
-		Self(bytes)
+		fn try_from(value: SignedUnverified) -> std::result::Result<Self, Self::Error> {
+			let (sg, pk, mg) = value.unpack();
+	
+			sg.verify(&mg, &pk)?;
+			
+			let Unsigned(content) = mg;
+			Ok(Self {
+				pk: pk.to_owned(),
+				content
+			})
+		}
 	}
-}
-
-impl TryFrom<Vec<u8>> for SignedUnverified {
-	type Error = Box<dyn std::error::Error>;
 
-	fn try_from(value: Vec<u8>) -> std::result::Result<Self, Self::Error> {
-		if value.len() <= 96 {
-			return Err(<Box<dyn std::error::Error>>::from(String::from("signed message packet is too short")))
+	#[derive(Debug)]
+	#[derive(Clone)]
+	#[derive(PartialEq)]
+	#[derive(Eq)]
+	#[derive(serde::Serialize)]
+	#[derive(serde::Deserialize)]
+	#[derive(derive_more::Deref)]
+	#[derive(derive_more::DerefMut)]
+	#[serde(try_from = "Vec<u8>")]
+	pub struct SignedUnverified(Vec<u8>);
+	
+	impl SignedUnverified {
+		pub fn verify(self) -> Result<SignedVerified> {
+			self.try_into()
 		}
-		let content: &[_] = &value[96..];
-		if content.is_empty() {
-			return Err(<Box<dyn std::error::Error>>::from(String::from("signed message content cannot be empty")))
+	}
+	
+	impl Unpack<(Signature, PublicKey, Unsigned)> for SignedUnverified {
+		fn unpack(self) -> (Signature, PublicKey, Unsigned) {
+			let Self(mut bytes) = self;				
+			let mut mgpk: Vec<_> = bytes.split_off(64);
+			let mg: Vec<_> = mgpk.split_off(32);
+			let mg: Unsigned = mg.try_into().expect("unsigned content slice is guaranteed to be non-empty via constructors");
+			let pk: [_; _] = mgpk.as_slice().try_into().expect("public key state corruption; must equal 32 bytes");
+			let pk: PublicKey = pk.into();
+			let sg: [_; _] = bytes.as_slice().try_into().expect("signature state corruption; remaining bytes must equal 64; guaranteed via constructors");
+			let sg: Signature = sg.into();
+			(sg, pk, mg)
 		}
-		Ok(Self(value))
 	}
-}
-
-#[derive(Debug)]
-#[derive(Clone)]
-#[derive(PartialEq)]
-#[derive(Eq)]
-#[derive(serde::Serialize)]
-#[derive(serde::Deserialize)]
-#[derive(derive_more::Deref)]
-#[derive(derive_more::DerefMut)]
-#[serde(try_from = "Vec<u8>")]
-pub struct Unsigned(Vec<u8>);
-
-impl Unsigned {
-	pub fn sign(&self, sk: &SecretKey) -> SignedUnverified {
-		(self, sk).into()
+	
+	impl From<(&Unsigned, &SecretKey)> for SignedUnverified {
+		fn from(value: (&Unsigned, &SecretKey)) -> Self {
+			let (Unsigned(mg), SecretKey(sk)) = value;
+			let sk: ed25519_dalek::SigningKey = ed25519_dalek::SigningKey::from_bytes(&sk);
+			let pk: [_; _] = sk.verifying_key().to_bytes();
+			let sg: ed25519_dalek::Signature = sk.sign(&mg);
+			let sg: [_; _] = sg.to_bytes();
+			let capacity: usize = 64 + 32 + mg.len();
+			
+			let mut bytes: Vec<_> = Vec::with_capacity(capacity);
+			bytes.extend_from_slice(&sg);
+			bytes.extend_from_slice(&pk);
+			bytes.extend_from_slice(&mg);
+			
+			Self(bytes)
+		}
 	}
-}
-
-impl TryFrom<Vec<u8>> for Unsigned {
-	type Error = Box<dyn std::error::Error>;
 
-	fn try_from(value: Vec<u8>) -> std::result::Result<Self, Self::Error> {
-		if value.len() == 0 {
-			return Err(<Box<dyn std::error::Error>>::from(String::from("message too short")))
+	impl TryFrom<Vec<u8>> for SignedUnverified {
+		type Error = Box<dyn std::error::Error>;
+		
+		fn try_from(value: Vec<u8>) -> std::result::Result<Self, Self::Error> {
+			if value.len() <= 96 {
+				return Err(<Box<dyn std::error::Error>>::from(String::from("signed message packet is too short")))
+			}
+			let content: &[_] = &value[96..];
+			if content.is_empty() {
+				return Err(<Box<dyn std::error::Error>>::from(String::from("signed message content cannot be empty")))
+			}
+			Ok(Self(value))
 		}
-		Ok(Self(value))
 	}
+	
+	#[derive(Debug)]
+	#[derive(Clone)]
+	#[derive(PartialEq)]
+	#[derive(Eq)]
+	#[derive(serde::Serialize)]
+	#[derive(serde::Deserialize)]
+	#[derive(derive_more::Deref)]
+	#[derive(derive_more::DerefMut)]
+	#[serde(try_from = "Vec<u8>")]
+	pub struct Unsigned(Vec<u8>);
+	
+	impl Unsigned {
+		pub fn sign(&self, sk: &SecretKey) -> SignedUnverified {
+			(self, sk).into()
+		}
+	}
+	
+	impl TryFrom<Vec<u8>> for Unsigned {
+		type Error = Box<dyn std::error::Error>;
+		
+		fn try_from(value: Vec<u8>) -> std::result::Result<Self, Self::Error> {
+			if value.len() == 0 {
+				return Err(<Box<dyn std::error::Error>>::from(String::from("message too short")))
+			}
+			Ok(Self(value))
+		}
+	}	
 }
 
 #[derive(Debug)]