Canonical serialize trait

mpc/mpc-core/src/commit.rs

@@ -1,6 +1,10 @@
-//! This module provides a hash commitment scheme for types which implement `serde::Serialize`
+//! This module provides a hash commitment scheme for types which implement
+//! [`CanonicalSerialize`](crate::serialize::CanonicalSerialize)
 
-use crate::hash::{Hash, SecureHash};
+use crate::{
+    hash::{Hash, SecureHash},
+    serialize::CanonicalSerialize,
+};
 use rand::{thread_rng, Rng};
 use serde::{Deserialize, Serialize};
 
@@ -27,15 +31,15 @@ impl Nonce {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Decommitment<T>
 where
-    T: Serialize,
+    T: CanonicalSerialize,
 {
     nonce: Nonce,
     data: T,
 }
 
 impl<T> Decommitment<T>
 where
-    T: Serialize,
+    T: CanonicalSerialize,
 {
     /// Creates a new decommitment
     pub fn new(data: T) -> Self {
@@ -80,10 +84,10 @@ where
     }
 }
 
-/// A trait for committing to arbitrary data which implements `serde::Serialize`
+/// A trait for committing to arbitrary data which implements [`CanonicalSerialize`](crate::serialize::CanonicalSerialize)
 pub trait HashCommit
 where
-    Self: serde::Serialize + Sized,
+    Self: CanonicalSerialize + Sized,
 {
     /// Creates a hash commitment to self
     fn hash_commit(self) -> (Decommitment<Self>, Hash) {
@@ -113,7 +117,7 @@ mod test {
         let message = [0, 1, 2, 3u8];
         let (mut decommitment, commitment) = message.hash_commit();
 
-        decommitment.nonce.0[0] = decommitment.nonce.0[0] - 1;
+        decommitment.nonce.0[0] -= 1;
 
         let err = decommitment.verify(&commitment).unwrap_err();
 
@@ -125,7 +129,7 @@ mod test {
         let message = [0, 1, 2, 3u8];
         let (mut decommitment, commitment) = message.hash_commit();
 
-        decommitment.data[0] = decommitment.data[0] + 1;
+        decommitment.data[0] += 1;
 
         let err = decommitment.verify(&commitment).unwrap_err();
 

mpc/mpc-core/src/hash.rs

@@ -7,6 +7,8 @@
 use blake3::Hasher;
 use serde::{Deserialize, Serialize};
 
+use crate::serialize::CanonicalSerialize;
+
 /// A secure hash
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Hash([u8; 32]);
@@ -27,12 +29,11 @@ impl From<[u8; 32]> for Hash {
 /// A trait for hashing serde serializable types
 pub trait SecureHash
 where
-    Self: serde::Serialize,
+    Self: CanonicalSerialize,
 {
     /// Creates a hash of self
     fn hash(&self) -> Hash {
-        let bytes = bcs::to_bytes(self).expect("serialization should not fail");
-        Hash(blake3::hash(&bytes).into())
+        Hash(blake3::hash(&self.to_bytes()).into())
     }
 }
 
@@ -48,9 +49,8 @@ where
 
     /// Creates a hash of self with a domain separator
     fn domain_separated_hash(&self) -> Hash {
-        let bytes = bcs::to_bytes(self).expect("serialization should not fail");
         let mut hasher = Self::hasher();
-        hasher.update(&bytes);
+        hasher.update(&self.to_bytes());
         Hash(hasher.finalize().into())
     }
 }

mpc/mpc-core/src/lib.rs

@@ -5,6 +5,7 @@
 mod block;
 pub mod commit;
 pub mod hash;
+pub mod serialize;
 pub mod utils;
 pub mod value;
 

mpc/mpc-core/src/serialize.rs

@@ -0,0 +1,14 @@
+//! Traits for canonical serialization of serde serializable types.
+
+/// A trait for canonical serialization of serde serializable types.
+///
+/// This trait provides a default implementation which uses
+/// [Binary Canonical Serialization (BCS)](https://docs.rs/bcs/latest/bcs/).
+pub trait CanonicalSerialize: serde::Serialize {
+    /// Serializes self into a byte vector
+    fn to_bytes(&self) -> Vec<u8> {
+        bcs::to_bytes(self).expect("serialization should not fail")
+    }
+}
+
+impl<T> CanonicalSerialize for T where T: serde::Serialize {}