Introduce baseline types required to implement validator set updates

shared/Cargo.toml

@@ -111,6 +111,7 @@ tendermint-proto = {git = "https://github.com/heliaxdev/tendermint-rs", rev = "9
 tendermint-proto-abci = {package = "tendermint-proto", git = "https://github.com/heliaxdev/tendermint-rs", branch = "murisi/jsfix", optional = true}
 tendermint-stable = {package = "tendermint", git = "https://github.com/heliaxdev/tendermint-rs", branch = "murisi/jsfix", optional = true}
 thiserror = "1.0.30"
+tiny-keccak = "2.0.2"
 tracing = "0.1.30"
 wasmer = {version = "=2.2.0", optional = true}
 wasmer-cache = {version = "=2.2.0", optional = true}

shared/src/proto/mod.rs

@@ -4,7 +4,8 @@ pub mod generated;
 mod types;
 
 pub use types::{
-    Dkg, Error, Intent, IntentGossipMessage, IntentId, Signed, SignedTxData, Tx,
+    Dkg, Error, Intent, IntentGossipMessage, IntentId, Signed, SignedSerialize,
+    SignedTxData, Tx,
 };
 
 #[cfg(test)]

shared/src/proto/types.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use std::convert::{TryFrom, TryInto};
 use std::fmt::Display;
 use std::hash::{Hash, Hasher};
+use std::marker::PhantomData;
 
 use borsh::schema::{Declaration, Definition};
 use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
@@ -51,54 +52,69 @@ pub struct SignedTxData {
     pub sig: common::Signature,
 }
 
-/// A generic signed data wrapper for Borsh encode-able data.
+/// A serialization method to provide to [`Signed`], such
+/// that we may sign serialized data.
+pub trait SignedSerialize<T> {
+    /// A byte vector containing the serialized data.
+    type Output: AsRef<[u8]>;
+
+    /// Encodes `data` as a byte vector,
+    /// with some arbitrary serialization method.
+    fn serialize(data: &T) -> Self::Output;
+}
+
+/// Tag type that indicates we should use [`BorshSerialize`]
+/// to sign data in a [`Signed`] wrapper.
+#[derive(Eq, PartialEq, Clone, Debug, Serialize, Deserialize)]
+pub struct SerializeWithBorsh;
+
+impl<T: BorshSerialize> SignedSerialize<T> for SerializeWithBorsh {
+    type Output = Vec<u8>;
+
+    fn serialize(data: &T) -> Vec<u8> {
+        data.try_to_vec()
+            .expect("Encoding data for signing shouldn't fail")
+    }
+}
+
+/// A generic signed data wrapper for serialize-able types.
+///
+/// The default serialization method is [`BorshSerialize`].
 #[derive(
     Clone, Debug, BorshSerialize, BorshDeserialize, Serialize, Deserialize,
 )]
-pub struct Signed<T: BorshSerialize + BorshDeserialize> {
+pub struct Signed<T, S = SerializeWithBorsh> {
     /// Arbitrary data to be signed
     pub data: T,
     /// The signature of the data
     pub sig: common::Signature,
+    /// The method to serialize the data with,
+    /// before it being signed
+    _serialization: PhantomData<S>,
 }
 
-impl<T> PartialEq for Signed<T>
-where
-    T: BorshSerialize + BorshDeserialize + PartialEq,
-{
+impl<S, T: Eq> Eq for Signed<T, S> {}
+
+impl<S, T: PartialEq> PartialEq for Signed<T, S> {
     fn eq(&self, other: &Self) -> bool {
         self.data == other.data && self.sig == other.sig
     }
 }
 
-impl<T> Eq for Signed<T> where
-    T: BorshSerialize + BorshDeserialize + Eq + PartialEq
-{
-}
-
-impl<T> Hash for Signed<T>
-where
-    T: BorshSerialize + BorshDeserialize + Hash,
-{
+impl<S, T: Hash> Hash for Signed<T, S> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.data.hash(state);
         self.sig.hash(state);
     }
 }
 
-impl<T> PartialOrd for Signed<T>
-where
-    T: BorshSerialize + BorshDeserialize + PartialOrd,
-{
+impl<S, T: PartialOrd> PartialOrd for Signed<T, S> {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         self.data.partial_cmp(&other.data)
     }
 }
 
-impl<T> BorshSchema for Signed<T>
-where
-    T: BorshSerialize + BorshDeserialize + BorshSchema,
-{
+impl<S, T: BorshSchema> BorshSchema for Signed<T, S> {
     fn add_definitions_recursively(
         definitions: &mut HashMap<Declaration, Definition>,
     ) {
@@ -117,17 +133,24 @@ where
     }
 }
 
-impl<T> Signed<T>
-where
-    T: BorshSerialize + BorshDeserialize,
-{
-    /// Initialize a new signed data.
+impl<T, S> Signed<T, S> {
+    /// Initialize a new [`Signed`] instance from an existing signature.
+    #[inline]
+    pub fn new_from(data: T, sig: common::Signature) -> Self {
+        Self {
+            data,
+            sig,
+            _serialization: PhantomData,
+        }
+    }
+}
+
+impl<T, S: SignedSerialize<T>> Signed<T, S> {
+    /// Initialize a new [`Signed`] instance.
     pub fn new(keypair: &common::SecretKey, data: T) -> Self {
-        let to_sign = data
-            .try_to_vec()
-            .expect("Encoding data for signing shouldn't fail");
-        let sig = common::SigScheme::sign(keypair, &to_sign);
-        Self { data, sig }
+        let to_sign = S::serialize(&data);
+        let sig = common::SigScheme::sign(keypair, to_sign.as_ref());
+        Self::new_from(data, sig)
     }
 
     /// Verify that the data has been signed by the secret key
@@ -136,11 +159,8 @@ where
         &self,
         pk: &common::PublicKey,
     ) -> std::result::Result<(), VerifySigError> {
-        let bytes = self
-            .data
-            .try_to_vec()
-            .expect("Encoding data for verifying signature shouldn't fail");
-        common::SigScheme::verify_signature_raw(pk, &bytes, &self.sig)
+        let bytes = S::serialize(&self.data);
+        common::SigScheme::verify_signature_raw(pk, bytes.as_ref(), &self.sig)
     }
 }
 

shared/src/types/ethereum_events.rs

@@ -51,6 +51,7 @@ impl From<u64> for Uint {
     Eq,
     PartialOrd,
     Ord,
+    Hash,
     BorshSerialize,
     BorshDeserialize,
     BorshSchema,

shared/src/types/transaction/protocol.rs

@@ -35,7 +35,9 @@ mod protocol_txs {
     use crate::proto::Tx;
     use crate::types::key::*;
     use crate::types::transaction::{EllipticCurve, TxError, TxType};
-    use crate::types::vote_extensions::ethereum_events;
+    use crate::types::vote_extensions::{
+        ethereum_events, validator_set_update,
+    };
 
     const TX_NEW_DKG_KP_WASM: &str = "tx_update_dkg_session_keypair.wasm";
 
@@ -79,6 +81,8 @@ mod protocol_txs {
         NewDkgKeypair(Tx),
         /// Ethereum events contained in vote extensions
         EthereumEvents(ethereum_events::VextDigest),
+        /// Validator set updates contained in vote extensions
+        ValidatorSetUpdate(validator_set_update::VextDigest),
     }
 
     impl ProtocolTxType {

shared/src/types/vote_extensions.rs

@@ -1,28 +1,29 @@
 //! This module contains types necessary for processing vote extensions.
 
 pub mod ethereum_events;
+pub mod validator_set_update;
 
-// TODO: add a `VoteExtension` type
-//
-// ```ignore
-// pub struct VoteExtension {
-//     pub ethereum_events: Signed<ethereum_events::Vext>,
-//     pub validator_set_update: Option<validator_set_update::EthSignedVext>,
-// }
-// ```
+use crate::proto::Signed;
 
-// TODO: add a `VoteExtensionDigest` type; this will contain
-// the values to be proposed, for a quorum of Ethereum events
-// vote extensions, and a separate quorum of validator set update
-// vote extensions
-//
-// ```ignore
-// pub struct VoteExtensionDigest {
-//     pub ethereum_events: ethereum_events::VextDigest,
-//     pub validator_set_update: Option<validator_set_update::VextDigest>,
-// }
-// ```
-//
-// from a `VoteExtensionDigest` we yield two signed `ProtocolTxType` values,
-// one of `ProtocolTxType::EthereumEvents` and the other of
-// `ProtocolTxType::ValidatorSetUpdate`
+/// This type represents the data we pass to the extension of
+/// a vote at the PreCommit phase of Tendermint.
+pub struct VoteExtension {
+    /// Vote extension data related with Ethereum events.
+    pub ethereum_events: Signed<ethereum_events::Vext>,
+    /// Vote extension data related with validator set updates.
+    pub validator_set_update: Option<validator_set_update::SignedVext>,
+}
+
+/// The digest of the signatures from different validators
+/// in [`VoteExtension`] instances.
+///
+/// From a [`VoteExtensionDigest`] we yield two signed
+/// [`crate::types::transaction::protocol::ProtocolTxType`] transactions:
+///   - A `ProtocolTxType::EthereumEvents` tx, and
+///   - A `ProtocolTxType::ValidatorSetUpdate` tx
+pub struct VoteExtensionDigest {
+    /// The digest of Ethereum events vote extension signatures.
+    pub ethereum_events: ethereum_events::VextDigest,
+    /// The digest of validator set updates vote extension signatures.
+    pub validator_set_update: Option<validator_set_update::VextDigest>,
+}

shared/src/types/vote_extensions/ethereum_events.rs

@@ -93,7 +93,7 @@ impl VextDigest {
             // of crate versions changing and such
             ext.ethereum_events.sort();
 
-            let signed = Signed { data: ext, sig };
+            let signed = Signed::new_from(ext, sig);
             extensions.push(signed);
         }
         extensions