feat: Trusted Setup Ceremony Primitives

manta-trusted-setup/Cargo.toml

@@ -53,8 +53,8 @@ ark-std = { version = "0.3.0", default-features = false }
 bincode = { version = "1.3.3", optional = true, default-features = false }
 blake2 = { version = "0.10.4", default-features = false }
 derivative = { version = "2.2.0", default-features = false, features = ["use_core"] }
-manta-crypto = { path = "../manta-crypto", default-features = false, features = ["arkworks", "getrandom", "rand_chacha"] }
-manta-util = { path = "../manta-util", default-features = false }
+manta-crypto = { path = "../manta-crypto", default-features = false, features = ["arkworks", "getrandom", "rand_chacha", "dalek"] }
+manta-util = { path = "../manta-util", default-features = false, features = ["serde"] }
 
 [dev-dependencies]
 ark-bls12-381 = { version = "0.3.0", default-features = false, features = ["curve", "scalar_field"] }

manta-trusted-setup/src/groth16/ceremony/client.rs

@@ -0,0 +1,35 @@
+// Copyright 2019-2022 Manta Network.
+// This file is part of manta-rs.
+//
+// manta-rs is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// manta-rs is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with manta-rs.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Trusted Setup Client
+
+// use crate::groth16::ceremony::{signature::Nonce, Ceremony, Participant};
+// use manta_crypto::dalek::ed25519::Ed25519;
+//
+// /// Client
+// pub struct Client<C, const CIRCUIT_COUNT: usize>
+// where
+//     C: Ceremony,
+// {
+//     /// Identifier
+//     Identifier: C::Identifier,
+//
+//     /// Current Nonce
+//     nonce: u64,
+//
+//     /// Private Key
+//     private_key: Ed25519,
+// }

manta-trusted-setup/src/groth16/ceremony/coordinator.rs

@@ -14,11 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with manta-rs.  If not, see <http://www.gnu.org/licenses/>.
 
-//! Groth16 Trusted Setup Ceremony Coordinator
+//! Coordinator
 
 use crate::{
     groth16::{
-        ceremony::{registry::Registry, Ceremony, Participant},
+        ceremony::{registry::Registry, Ceremony, Nonce, Participant},
         mpc::StateSize,
     },
     mpc::{Challenge, Proof, State},
@@ -47,24 +47,20 @@ pub type Queue<C, const LEVEL_COUNT: usize> =
     derive(Deserialize, Serialize),
     serde(
         bound(
-            deserialize = r"
-            R: Deserialize<'de>,
-            Queue<C, LEVEL_COUNT>: Deserialize<'de>,
-            C::Identifier: Deserialize<'de>,
-            State<C>: Deserialize<'de>,
-            Challenge<C>: Deserialize<'de>,
-            Proof<C>: Deserialize<'de>,
-            C::Participant: Deserialize<'de>,
-        ",
             serialize = r"
-            R: Serialize,
-            Queue<C, LEVEL_COUNT>: Serialize,
-            C::Identifier: Serialize,
-            State<C>: Serialize,
-            Challenge<C>: Serialize,
-            Proof<C>: Serialize,
-            C::Participant: Serialize,
-        "
+                R: Serialize,
+                State<C>: Serialize,
+                Challenge<C>: Serialize,
+                Proof<C>: Serialize,
+                C::Participant: Serialize,
+            ",
+            deserialize = r"
+                R: Deserialize<'de>,
+                State<C>: Deserialize<'de>,
+                Challenge<C>: Deserialize<'de>,
+                Proof<C>: Deserialize<'de>,
+                C::Participant: Deserialize<'de>,
+            "
         ),
         crate = "manta_util::serde",
         deny_unknown_fields
@@ -78,12 +74,6 @@ where
     /// Participant Registry
     pub registry: R,
 
-    /// Participant Queue
-    pub queue: Queue<C, LEVEL_COUNT>,
-
-    /// Participant Lock
-    pub participant_lock: Timed<Option<C::Identifier>>,
-
     /// State
     pub state: StateArray<C, CIRCUIT_COUNT>,
 
@@ -103,6 +93,14 @@ where
 
     /// Current Round Number
     pub round: usize,
+
+    /// Participant Queue
+    #[serde(skip)]
+    pub queue: Queue<C, LEVEL_COUNT>,
+
+    /// Participant Lock
+    #[serde(skip)]
+    pub participant_lock: Timed<Option<C::Identifier>>,
 }
 
 impl<C, R, const CIRCUIT_COUNT: usize, const LEVEL_COUNT: usize>
@@ -111,12 +109,6 @@ where
     C: Ceremony,
     R: Registry<C::Identifier, C::Participant>,
 {
-    /// Returns the current round number.
-    #[inline]
-    pub fn round(&self) -> usize {
-        self.round
-    }
-
     /// Returns a shared reference to the participant data for `id` from the registry.
     #[inline]
     pub fn participant(&self, id: &C::Identifier) -> Option<&C::Participant> {
@@ -141,4 +133,10 @@ where
         self.queue
             .push_back_at(participant.level(), participant.id().clone());
     }
+
+    /// Gets nonce of a participant with `id`.
+    #[inline]
+    pub fn nonce(&self, id: &C::Identifier) -> Option<Nonce<C>> {
+        Some(self.registry.get(id)?.get_nonce())
+    }
 }

manta-trusted-setup/src/groth16/ceremony/message.rs

@@ -0,0 +1,196 @@
+// Copyright 2019-2022 Manta Network.
+// This file is part of manta-rs.
+//
+// manta-rs is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// manta-rs is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with manta-rs.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Messages through Network
+
+use crate::{
+    groth16::{
+        ceremony::{signature::sign, Ceremony, CeremonyError, Nonce, Proof, Signature, SigningKey},
+        mpc::{State, StateSize},
+    },
+    mpc::Challenge,
+};
+use manta_crypto::arkworks::serialize::{CanonicalDeserialize, CanonicalSerialize};
+use manta_util::{
+    serde::{Deserialize, Serialize},
+    Array, BytesRepr,
+};
+
+/// MPC States
+#[derive(Deserialize, Serialize)]
+#[serde(
+    bound(
+        serialize = "State<C::Pairing>: CanonicalSerialize, Challenge<C>: CanonicalSerialize",
+        deserialize = "State<C::Pairing>: CanonicalDeserialize, Challenge<C>: CanonicalDeserialize"
+    ),
+    crate = "manta_util::serde",
+    deny_unknown_fields
+)]
+pub struct MPCState<C, const N: usize>
+where
+    C: Ceremony,
+{
+    /// State
+    pub state: Array<BytesRepr<State<C::Pairing>>, N>,
+
+    /// Challenge
+    pub challenge: Array<BytesRepr<Challenge<C>>, N>,
+}
+
+/// Contribute States
+#[derive(Deserialize, Serialize)]
+#[serde(
+    bound(
+        serialize = "State<C::Pairing>: CanonicalSerialize, Proof<C>: CanonicalSerialize",
+        deserialize = "State<C::Pairing>: CanonicalDeserialize, Proof<C>: CanonicalDeserialize"
+    ),
+    crate = "manta_util::serde",
+    deny_unknown_fields
+)]
+pub struct ContributeState<C, const CIRCUIT_COUNT: usize>
+where
+    C: Ceremony,
+{
+    /// State
+    pub state: Array<BytesRepr<State<C::Pairing>>, CIRCUIT_COUNT>,
+
+    /// Proof
+    pub proof: Array<BytesRepr<Proof<C>>, CIRCUIT_COUNT>,
+}
+
+/// Response for State Sizes
+#[derive(Clone, Serialize, Deserialize)]
+#[serde(crate = "manta_util::serde", deny_unknown_fields)]
+pub struct ServerSize<const CIRCUIT_COUNT: usize>(pub Array<StateSize, CIRCUIT_COUNT>);
+
+impl<const CIRCUIT_COUNT: usize> From<Array<StateSize, CIRCUIT_COUNT>>
+    for ServerSize<CIRCUIT_COUNT>
+{
+    fn from(inner: Array<StateSize, CIRCUIT_COUNT>) -> Self {
+        ServerSize(inner)
+    }
+}
+
+/// Query Request
+#[derive(Deserialize, Serialize)]
+#[serde(crate = "manta_util::serde", deny_unknown_fields)]
+pub struct QueryRequest;
+
+/// Response for [`QueryRequest`]
+#[derive(Deserialize, Serialize)]
+#[serde(
+    bound(
+        serialize = "MPCState<C, CIRCUIT_COUNT>: Serialize",
+        deserialize = "MPCState<C, CIRCUIT_COUNT>: Deserialize<'de>"
+    ),
+    crate = "manta_util::serde",
+    deny_unknown_fields
+)]
+pub enum QueryResponse<C, const CIRCUIT_COUNT: usize>
+where
+    C: Ceremony,
+{
+    /// Queue Position
+    QueuePosition(usize),
+
+    /// MPC State
+    Mpc(MPCState<C, CIRCUIT_COUNT>),
+}
+
+/// Contribute Request
+#[derive(Serialize, Deserialize)]
+#[serde(
+    bound(
+        serialize = "ContributeState<C, CIRCUIT_COUNT>: Serialize",
+        deserialize = "ContributeState<C, CIRCUIT_COUNT>: Deserialize<'de>"
+    ),
+    crate = "manta_util::serde",
+    deny_unknown_fields
+)]
+pub struct ContributeRequest<C, const CIRCUIT_COUNT: usize>
+where
+    C: Ceremony,
+{
+    /// Contribute state including state and proof
+    pub contribute_state: ContributeState<C, CIRCUIT_COUNT>,
+}
+
+/// Signed Message
+#[derive(Deserialize, Serialize)]
+#[serde(
+    bound(
+        serialize = r"
+            C::Identifier: Serialize,
+            T: Serialize,
+            Nonce<C>: Serialize,
+            Signature<C>: Serialize,
+        ",
+        deserialize = r"
+            C::Identifier: Deserialize<'de>,
+            T: Deserialize<'de>,
+            Nonce<C>: Deserialize<'de>,
+            Signature<C>: Deserialize<'de>,
+        ",
+    ),
+    crate = "manta_util::serde",
+    deny_unknown_fields
+)]
+pub struct Signed<T, C>
+where
+    C: Ceremony,
+{
+    /// Message
+    pub message: T,
+
+    /// Nonce
+    pub nonce: Nonce<C>,
+
+    /// Signature
+    pub signature: Signature<C>,
+
+    /// Participant Identifier
+    pub identifier: C::Identifier,
+}
+
+impl<T, C> Signed<T, C>
+where
+    C: Ceremony,
+{
+    /// Generates a signed message with `signing_key` on `message` and `nonce`.
+    #[inline]
+    pub fn new(
+        message: T,
+        nonce: &Nonce<C>,
+        signing_key: &SigningKey<C>,
+        identifier: C::Identifier,
+    ) -> Result<Self, CeremonyError<C>>
+    where
+        T: Serialize,
+        Nonce<C>: Clone,
+    {
+        let signature = match sign::<_, C::SignatureScheme>(signing_key, nonce.clone(), &message) {
+            Ok(signature) => signature,
+            Err(_) => return Err(CeremonyError::<C>::BadRequest),
+        };
+        let message = Signed {
+            message,
+            nonce: nonce.clone(),
+            signature,
+            identifier,
+        };
+        Ok(message)
+    }
+}