Use CBOR for certified block.

Adds an `adapters` crate to implement CBOR encoding/decoding for
external types.

Uses mostly CBOR maps for a slightly more verbose encoding which may
be easier to parse in other languages.

As an additonal demo, the certifier protocol messages are also CBOR now.

Author: twittner

Cargo.lock

@@ -1,5 +1,6 @@
 [workspace]
 members = [
+    "adapters",
     "cliquenet",
     "metrics",
     "multisig",
@@ -67,6 +68,7 @@ ethereum_ssz = "0.9.0"
 futures = { version = "0.3", default-features = false, features = ["alloc"] }
 generic-array = { version = "0.14.7", features = ["serde", "zeroize"] }
 http = "1.3.1"
+minicbor = { version = "2.1.1", features = ["full"] }
 nohash-hasher = "0.2"
 parking_lot = "0.12.3"
 portpicker = "0.1.1"

Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "adapters"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+bytes = { workspace = true }
+committable = { workspace = true }
+minicbor = { workspace = true }

adapters/Cargo.toml

@@ -0,0 +1,35 @@
+use std::convert::Infallible;
+
+use bytes::{Bytes, BytesMut};
+use minicbor::decode::{Decoder, Error as DecodeError};
+use minicbor::encode::{Encoder, Error as EncodeError, Write};
+
+pub fn encode<C, W>(b: &Bytes, e: &mut Encoder<W>, _: &mut C) -> Result<(), EncodeError<W::Error>>
+where
+    W: Write,
+{
+    e.bytes(b)?.ok()
+}
+
+pub fn decode<'b, C>(d: &mut Decoder<'b>, _: &mut C) -> Result<Bytes, DecodeError> {
+    Ok(Bytes::copy_from_slice(d.bytes()?))
+}
+
+/// `BytesWrite` can be used to encode directly into `BytesMut`.
+#[derive(Default)]
+pub struct BytesWriter(BytesMut);
+
+impl Write for BytesWriter {
+    type Error = Infallible;
+
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        self.0.extend_from_slice(buf);
+        Ok(())
+    }
+}
+
+impl From<BytesWriter> for BytesMut {
+    fn from(value: BytesWriter) -> Self {
+        value.0
+    }
+}

adapters/src/bytes.rs

@@ -0,0 +1,28 @@
+use committable::{Commitment, Committable};
+use minicbor::decode::{Decoder, Error as DecodeError};
+use minicbor::encode::{Encoder, Error as EncodeError, Write};
+
+const LEN: usize = 32;
+
+pub fn encode<D, C, W>(
+    d: &Commitment<D>,
+    e: &mut Encoder<W>,
+    _: &mut C,
+) -> Result<(), EncodeError<W::Error>>
+where
+    W: Write,
+    D: Committable,
+{
+    e.bytes(d.as_ref())?.ok()
+}
+
+pub fn decode<'b, D, C>(d: &mut Decoder<'b>, _: &mut C) -> Result<Commitment<D>, DecodeError>
+where
+    D: Committable,
+{
+    let p = d.position();
+    let a = d.bytes()?;
+    <[u8; LEN]>::try_from(a)
+        .map(Commitment::from_raw)
+        .map_err(|e| DecodeError::custom(e).at(p))
+}

adapters/src/commitment.rs

@@ -0,0 +1,4 @@
+//! Provide CBOR encode/decode functionality for types that do not implement `Encode`/`Decode`.
+
+pub mod bytes;
+pub mod commitment;

adapters/src/lib.rs

@@ -9,13 +9,15 @@ rust-version.workspace = true
 benchmark = []
 
 [dependencies]
+adapters = { path = "../adapters" }
 bimap = { workspace = true }
 bincode = { workspace = true }
 bs58 = { workspace = true }
 committable = { workspace = true }
 constant_time_eq = { workspace = true }
 ed25519-compact = { workspace = true }
 either = { workspace = true }
+minicbor = { workspace = true }
 rayon = { workspace = true }
 secp256k1 = { workspace = true }
 serde = { workspace = true }

multisig/Cargo.toml

@@ -2,14 +2,23 @@ use std::{collections::BTreeMap, num::NonZeroUsize};
 
 use committable::{Commitment, Committable, RawCommitmentBuilder};
 use constant_time_eq::constant_time_eq;
+use minicbor::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 
 use crate::{Committee, KeyId, PublicKey, Signature};
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[derive(
+    Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize, Encode, Decode,
+)]
+#[cbor(map)]
 pub struct Certificate<D: Committable> {
+    #[cbor(n(0))]
     data: D,
+
+    #[cbor(n(1), with = "adapters::commitment")]
     commitment: Commitment<D>,
+
+    #[cbor(n(2))]
     signatures: BTreeMap<KeyId, Signature>,
 }
 

multisig/src/cert.rs

@@ -5,6 +5,7 @@ use std::sync::Arc;
 
 use bimap::BiBTreeMap;
 use committable::{Commitment, Committable, RawCommitmentBuilder};
+use minicbor::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 
 use super::{KeyId, PublicKey};
@@ -103,7 +104,10 @@ impl Committee {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[derive(
+    Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Encode, Decode,
+)]
+#[cbor(transparent)]
 #[serde(transparent)]
 pub struct CommitteeId(u64);
 

multisig/src/committee.rs

@@ -1,16 +1,19 @@
 use std::{hash::Hash, marker::PhantomData, ops::Deref};
 
 use committable::{Commitment, Committable, RawCommitmentBuilder};
+use minicbor::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 
 use crate::{Committee, Keypair, Signed};
 
 /// Marker type to denote envelopes whose signature has not been validated.
-#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[derive(
+    Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Deserialize, Encode, Decode,
+)]
 pub enum Unchecked {}
 
 /// Marker type to denote envelopes whose signature has been validated.
-#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Encode)]
 pub enum Validated {}
 
 /// An envelope contains data, its signed commitment hash and the signing key.
@@ -25,12 +28,18 @@ pub enum Validated {}
 /// let _: Envelope<Signature, Validated> =
 ///     bincode::serde::decode_from_slice(&[], bincode::config::standard()).unwrap().0;
 /// ```
-#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[derive(
+    Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize, Encode, Decode,
+)]
 #[serde(bound(deserialize = "D: Deserialize<'de>, S: Deserialize<'de>"))]
+#[cbor(map)]
 pub struct Envelope<D: Committable, S> {
+    #[cbor(n(0))]
     signed: Signed<D>,
+
+    #[cbor(skip)]
     #[serde(skip)]
-    _marker: PhantomData<fn(S)>,
+    _marker: PhantomData<fn(&S)>,
 }
 
 impl<D: Committable> Envelope<D, Validated> {