TS Client and Server Binaries

CHANGELOG.md

@@ -5,6 +5,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 ### Added
+- [\#259](https://github.com/Manta-Network/manta-rs/pull/257) Add server binaries for the trusted setup
 - [\#303](https://github.com/Manta-Network/manta-rs/pull/303) Poseidon Hash and AES decryption WASM benchmarks.
 
 ### Changed

manta-crypto/src/dalek/ed25519.rs

@@ -40,14 +40,10 @@ macro_rules! byte_conversion {
         ///
         /// We don't need to return an error here because `bytes` already has the correct length.
         #[inline]
-        pub fn $name(bytes: [u8; $len]) -> $type {
+        pub fn $name(bytes: [u8; $len]) -> Result<$type, ByteConversionError> {
             match $type::from_bytes(&bytes) {
-                Ok(value) => value,
-                _ => unreachable!(concat!(
-                    "We are guaranteed the correct number of bytes from `",
-                    stringify!($len),
-                    "`."
-                )),
+                Ok(value) => Ok(value),
+                _ => Err(ByteConversionError::IncorrectByteSize),
             }
         }
     };
@@ -57,10 +53,17 @@ byte_conversion!(secret_key_from_bytes, SecretKey, SECRET_KEY_LENGTH);
 byte_conversion!(public_key_from_bytes, PublicKey, PUBLIC_KEY_LENGTH);
 byte_conversion!(signature_from_bytes, Signature, SIGNATURE_LENGTH);
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+/// Errors that can occur when converting from bytes
+pub enum ByteConversionError {
+    /// Incorrect Number of Bytes
+    IncorrectByteSize,
+}
+
 /// Clones the `secret_key` by serializing and then deserializing.
 #[inline]
 pub fn clone_secret_key(secret_key: &SecretKey) -> SecretKey {
-    secret_key_from_bytes(secret_key.to_bytes())
+    secret_key_from_bytes(secret_key.to_bytes()).expect("Byte conversion cannot fail here.")
 }
 
 /// Generates a [`Keypair`] from `secret_key`.
@@ -78,7 +81,7 @@ pub fn generate_secret_key<R>(rng: &mut R) -> SecretKey
 where
     R: CryptoRng + RngCore,
 {
-    secret_key_from_bytes(rng.gen())
+    secret_key_from_bytes(rng.gen()).expect("RNG will generate correct number of bytes.")
 }
 
 /// Generates a [`Keypair`] from `rng`.
@@ -99,6 +102,16 @@ where
 #[derivative(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct Ed25519<M>(PhantomData<M>);
 
+/// The serialization of a [`PublicKey`].
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct VerifyingKey(Array<u8, 32>);
+
+impl From<PublicKey> for VerifyingKey {
+    fn from(k: PublicKey) -> Self {
+        Self(Array::from_unchecked(*k.as_bytes()))
+    }
+}
+
 impl<M> MessageType for Ed25519<M> {
     type Message = M;
 }

manta-trusted-setup/Cargo.toml

@@ -26,40 +26,56 @@ maintenance = { status = "actively-developed" }
 
 [[bin]]
 name = "groth16_phase2_client"
-required-features = ["clap", "ppot-client", "reqwest", "tokio"]
+required-features = ["client"]
 
 [[bin]]
 name = "groth16_phase2_prepare"
-required-features = ["clap", "memmap", "ppot-client", "serde", "tokio"]
+required-features = ["coordinator"]
+
+[[bin]]
+name = "groth16_phase2_server"
+required-features = ["coordinator"]
 
 [[bin]]
 name = "groth16_phase2_verifier"
-required-features = ["clap", "memmap", "ppot-client", "reqwest", "tokio"]
+required-features = ["coordinator"]
 
 [features]
 # Bincode for Message Signing
 bincode = ["dep:bincode", "serde"]
 
-# PPoT Client Features
-ppot-client = [
+# Trusted Setup Ceremony
+ceremony = [
     "bincode",
     "bs58",
+    "chrono",
+    "clap",
     "colored",
     "console",
     "csv",
     "dialoguer",
+    "manta-crypto/ark-bn254",
+    "reqwest",
+    "serde",
+    "tiny-bip39",
+    "tokio"
+ ]
+
+# Trusted Setup Client
+client = [
+    "async-std", 
+    "ceremony",
     "hex/std",
+    "manta-util/tide",
     "parking_lot",
-    "ppot",
-    "tiny-bip39",
 ]
 
+# Trusted Setup Coordinator
+coordinator = ["client", "memmap", "parking_lot", "serde_json", "std",]
+
 # CSV for Ceremony Registries
 csv = ["dep:csv", "serde", "std"]
 
-# Perpetual Powers of Tau Ceremony
-ppot = ["manta-crypto/ark-bn254"]
-
 # Rayon Parallelization
 rayon = ["manta-util/rayon"]
 
@@ -76,21 +92,20 @@ serde = [
 ]
 
 # Standard Library
-std = ["ark-std/std", "manta-util/std"]
+std = ["ark-std/std", "hex/std", "manta-util/std"]
 
 # Testing Frameworks
 test = ["manta-crypto/test"]
 
-# Tide HTTP Server
-tide = ["manta-util/tide"]
-
 [dependencies]
 ark-groth16 = { version = "0.3.0", default-features = false }
 ark-poly = { version = "0.3.0", default-features = false }
 ark-std = { version = "0.3.0", default-features = false }
+async-std = { version = "1.6.0", optional = true, features = ["attributes", "tokio1"] }
 bincode = { version = "1.3.3", optional = true, default-features = false }
 blake2 = { version = "0.10.6", default-features = false }
 bs58 = { version = "0.4.0", optional = true, default-features = false, features = ["alloc"] }
+chrono = { version = "0.4.19", optional = true, default-features = false, features = ["clock"] }
 clap = { version = "3.2.23", optional = true, default-features = false, features = ["color", "derive", "std", "suggestions", "unicode", "wrap_help"] }
 colored = { version = "2.0.0", optional = true, default-features = false }
 console = { version = "0.15.4", optional = true, default-features = false }
@@ -105,7 +120,7 @@ memmap = { version = "0.7.0", optional = true, default-features = false }
 parking_lot = { version = "0.12.1", optional = true, default-features = false }
 serde_json = { version = "1.0.91", optional = true, default-features = false, features = ["alloc"] }
 tiny-bip39 = { version = "1.0.0", optional = true, default-features = false } 
-tokio = { version = "1.24.1", optional = true, default-features = false, features = ["rt-multi-thread", "io-std"] }
+tokio = { version = "1.24.1", optional = true, default-features = false, features = ["rt-multi-thread", "io-std", "io-util", "time"] }
 
 [dev-dependencies]
 ark-snark = { version = "0.3.0", default-features = false }

manta-trusted-setup/src/bin/groth16_phase2_server.rs

@@ -0,0 +1,91 @@
+// 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 Ceremony Server
+
+use clap::Parser;
+use manta_trusted_setup::groth16::ceremony::{
+    config::ppot::{Config, Participant},
+    server::Server,
+    CeremonyError,
+};
+use manta_util::{
+    http::tide::{self, execute},
+    Array,
+};
+use std::{collections::HashMap, path::PathBuf, time::Duration};
+
+/// Registry type
+type Registry = HashMap<Array<u8, 32>, Participant>;
+
+/// Current server configuration
+type S = Server<Config, Registry, 2, 3>;
+
+/// Contribution time limit in seconds
+const TIME_LIMIT: u64 = 60;
+
+/// Server CLI
+#[derive(Debug, Parser)]
+pub struct Arguments {
+    /// Path to directory where server recovers/saves state
+    recovery_dir_path: String,
+
+    /// Path to file from which server updates internal registry
+    registry_path: String,
+
+    /// Path to html file to serve to web browsers
+    homepage_path: String,
+}
+
+impl Arguments {
+    /// Runs a server.
+    #[inline]
+    pub async fn run(self) -> Result<(), CeremonyError<Config>> {
+        let server = S::recover(
+            PathBuf::from(self.recovery_dir_path),
+            PathBuf::from(self.registry_path),
+            Duration::from_secs(TIME_LIMIT),
+        )
+        .expect("Unable to recover from file");
+
+        println!("Network is running!");
+        let mut api = tide::Server::with_state(server);
+        api.at("/").serve_file(&self.homepage_path).map_err(|_| {
+            CeremonyError::<Config>::Network {
+                message: "Cannot load landing page.".to_string(),
+            }
+        })?;
+        api.at("/start")
+            .post(|r| execute(r, Server::start_endpoint));
+        api.at("/query")
+            .post(|r| execute(r, Server::query_endpoint));
+        api.at("/update")
+            .post(|r| execute(r, Server::update_endpoint));
+
+        api.listen("127.0.0.1:8080")
+            .await
+            .expect("Should create a listener.");
+        Ok(())
+    }
+}
+
+#[async_std::main]
+async fn main() {
+    Arguments::parse()
+        .run()
+        .await
+        .expect("Server error occurred");
+}

manta-trusted-setup/src/ceremony/registry/csv.rs

@@ -17,8 +17,13 @@
 //! Trusted Setup Ceremony Registry CSV Compatibility
 
 use crate::ceremony::registry::Registry;
+use core::fmt::Debug;
 use manta_util::serde::de::DeserializeOwned;
-use std::{fs::File, path::Path};
+use std::{
+    fs::{File, OpenOptions},
+    io::{Seek, SeekFrom},
+    path::Path,
+};
 
 /// CSV Record
 pub trait Record<I, V>: DeserializeOwned {
@@ -56,11 +61,58 @@ where
     T: Record<I, V>,
     R: Registry<I, V>,
     P: AsRef<Path>,
+    T::Error: Debug,
 {
     let mut registry = R::new();
-    for record in csv::Reader::from_reader(File::open(path)?).deserialize() {
-        let (identifier, participant) = T::parse(record?).map_err(Error::Parse)?;
-        registry.insert(identifier, participant);
-    }
+    load_append_entries::<_, _, T, _, _>(path, &mut registry)?;
     Ok(registry)
 }
+
+/// Loads new entries into `registry` from `path` using `T` as the record type without overwriting
+/// existing entries. Returns the number of new entries added.
+#[inline]
+pub fn load_append_entries<I, V, T, R, P>(
+    path: P,
+    registry: &mut R,
+) -> Result<usize, Error<T::Error>>
+where
+    T: Record<I, V>,
+    R: Registry<I, V>,
+    P: AsRef<Path>,
+    T::Error: Debug,
+{
+    let length = registry.len();
+
+    for (number, record) in csv::Reader::from_reader(File::open(path)?)
+        .deserialize()
+        .flatten()
+        .enumerate()
+    {
+        match T::parse(record) {
+            Ok((identifier, participant)) => {
+                registry.insert(identifier, participant);
+            }
+            Err(e) => {
+                println!("Line: {} Parsing error {e:?}", number + 2);
+            }
+        };
+    }
+    Ok(registry.len() - length)
+}
+
+/// Build an append-only CSV writer from a file path.
+/// Missing files are created.
+pub fn append_only_csv_writer<E, P>(path: P) -> Result<csv::Writer<File>, E>
+where
+    P: AsRef<Path>,
+    E: From<std::io::Error>,
+{
+    let mut file = OpenOptions::new().write(true).create(true).open(&path)?;
+    let mut file_is_empty = false;
+    if file.seek(SeekFrom::End(0))? == 0 {
+        file_is_empty = true;
+    }
+    Ok(csv::WriterBuilder::new()
+        .has_headers(file_is_empty)
+        .from_writer(file))
+}

manta-trusted-setup/src/groth16/ceremony/config/mod.rs

@@ -16,6 +16,6 @@
 
 //! Groth16 Trusted Setup Ceremony Configurations
 
-#[cfg(feature = "ppot-client")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "ppot-client")))]
+#[cfg(feature = "client")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "client")))]
 pub mod ppot;