Save slate participant messages in database (#2441)

* Save and display optional slate messages

* rustfmt

* fixes and test updates

* rustfmt

* output json

* rustfmt

* add better serialisation of slate message, rename to secp_ser, add tests for serialization functions

* rustfmt

* max length for message enforced by API

* rustfmt

core/src/libtx/mod.rs

@@ -26,7 +26,7 @@ pub mod build;
 mod error;
 pub mod proof;
 pub mod reward;
-pub mod serialization;
+pub mod secp_ser;
 pub mod slate;
 
 use crate::consensus;

core/src/libtx/secp_ser.rs

@@ -173,3 +173,58 @@ where
 {
 	serializer.serialize_str(&to_hex(bytes.as_ref().to_vec()))
 }
+
+// Test serialization methods of components that are being used
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::libtx::aggsig;
+	use crate::util::secp::key::{PublicKey, SecretKey};
+	use crate::util::secp::{Message, Signature};
+	use crate::util::static_secp_instance;
+
+	use serde_json;
+
+	use rand::{thread_rng, Rng};
+
+	#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
+	struct SerTest {
+		#[serde(with = "pubkey_serde")]
+		pub pub_key: PublicKey,
+		#[serde(with = "option_sig_serde")]
+		pub opt_sig: Option<Signature>,
+		#[serde(with = "sig_serde")]
+		pub sig: Signature,
+	}
+
+	impl SerTest {
+		pub fn random() -> SerTest {
+			let static_secp = static_secp_instance();
+			let secp = static_secp.lock();
+			let sk = SecretKey::new(&secp, &mut thread_rng());
+			let mut msg = [0u8; 32];
+			thread_rng().fill(&mut msg);
+			let msg = Message::from_slice(&msg).unwrap();
+			let sig = aggsig::sign_single(&secp, &msg, &sk, None).unwrap();
+			SerTest {
+				pub_key: PublicKey::from_secret_key(&secp, &sk).unwrap(),
+				opt_sig: Some(sig.clone()),
+				sig: sig.clone(),
+			}
+		}
+	}
+
+	#[test]
+	fn ser_secp_primitives() {
+		for _ in 0..10 {
+			let s = SerTest::random();
+			println!("Before Serialization: {:?}", s);
+			let serialized = serde_json::to_string_pretty(&s).unwrap();
+			println!("JSON: {}", serialized);
+			let deserialized: SerTest = serde_json::from_str(&serialized).unwrap();
+			println!("After Serialization: {:?}", deserialized);
+			println!();
+			assert_eq!(s, deserialized);
+		}
+	}
+}

core/src/libtx/slate.rs

@@ -22,7 +22,7 @@ use crate::core::transaction::{kernel_features, kernel_sig_msg, Transaction, Wei
 use crate::core::verifier_cache::LruVerifierCache;
 use crate::keychain::{BlindSum, BlindingFactor, Keychain};
 use crate::libtx::error::{Error, ErrorKind};
-use crate::libtx::{aggsig, build, tx_fee};
+use crate::libtx::{aggsig, build, secp_ser, tx_fee};
 use crate::util::secp;
 use crate::util::secp::key::{PublicKey, SecretKey};
 use crate::util::secp::Signature;
@@ -66,6 +66,33 @@ impl ParticipantData {
 	}
 }
 
+/// Public message data (for serialising and storage)
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ParticipantMessageData {
+	/// id of the particpant in the tx
+	pub id: u64,
+	/// Public key
+	#[serde(with = "secp_ser::pubkey_serde")]
+	pub public_key: PublicKey,
+	/// Message,
+	pub message: Option<String>,
+	/// Signature
+	#[serde(with = "secp_ser::option_sig_serde")]
+	pub message_sig: Option<Signature>,
+}
+
+impl ParticipantMessageData {
+	/// extract relevant message data from participant data
+	pub fn from_participant_data(p: &ParticipantData) -> ParticipantMessageData {
+		ParticipantMessageData {
+			id: p.id,
+			public_key: p.public_blind_excess,
+			message: p.message.clone(),
+			message_sig: p.message_sig.clone(),
+		}
+	}
+}
+
 /// A 'Slate' is passed around to all parties to build up all of the public
 /// transaction data needed to create a finalized transaction. Callers can pass
 /// the slate around by whatever means they choose, (but we can provide some
@@ -94,6 +121,13 @@ pub struct Slate {
 	pub participant_data: Vec<ParticipantData>,
 }
 
+/// Helper just to facilitate serialization
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ParticipantMessages {
+	/// included messages
+	pub messages: Vec<ParticipantMessageData>,
+}
+
 impl Slate {
 	/// Create a new slate
 	pub fn blank(num_participants: usize) -> Slate {
@@ -274,10 +308,19 @@ impl Slate {
 			message: message,
 			message_sig: message_sig,
 		});
-
 		Ok(())
 	}
 
+	/// helper to return all participant messages
+	pub fn participant_messages(&self) -> ParticipantMessages {
+		let mut ret = ParticipantMessages { messages: vec![] };
+		for ref m in self.participant_data.iter() {
+			ret.messages
+				.push(ParticipantMessageData::from_participant_data(m));
+		}
+		ret
+	}
+
 	/// Somebody involved needs to generate an offset with their private key
 	/// For now, we'll have the transaction initiator be responsible for it
 	/// Return offset private key for the participant to use later in the