mpc server: back to old commit

Author: teddav

mpc-server/Cargo.toml

@@ -18,8 +18,10 @@ ark-bn254 = "^0.5.0"
 
 # co-noir = { path = "../../conoir-experiments/co-snarks/co-noir/co-noir" }
 # co-ultrahonk = { path = "../../conoir-experiments/co-snarks/co-noir/co-ultrahonk" }
-co-noir = { git = "https://github.com/TaceoLabs/co-snarks", rev = "55f4ca3" }
-co-ultrahonk = { git = "https://github.com/TaceoLabs/co-snarks", rev = "55f4ca3" }
+# co-noir = { git = "https://github.com/TaceoLabs/co-snarks", rev = "55f4ca3" }
+# co-ultrahonk = { git = "https://github.com/TaceoLabs/co-snarks", rev = "55f4ca3" }
+co-noir = { git = "https://github.com/TaceoLabs/co-snarks", rev = "b294667" }
+co-ultrahonk = { git = "https://github.com/TaceoLabs/co-snarks", rev = "b294667" }
 
 noirc-artifacts = { version = "1.0.0-beta.4", git = "https://github.com/noir-lang/noir/", tag = "v1.0.0-beta.4", package = "noirc_artifacts" }
 axum = { version = "0.8.4", features = ["multipart"] }

mpc-server/src/main.rs

@@ -186,12 +186,110 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
                 .on_response(trace::DefaultOnResponse::new().level(Level::INFO)),
         );
 
-    // let listener = tokio::net::TcpListener::bind("0.0.0.0:8000").await?;
-    // axum::serve(listener, app).await?;
-    let addr = SocketAddr::from(([0, 0, 0, 0], 8000));
-    axum_server::bind_rustls(addr, config)
-        .serve(app.into_make_service())
-        .await?;
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:8000").await?;
+    axum::serve(listener, app).await?;
+    // let addr = SocketAddr::from(([0, 0, 0, 0], 8000));
+    // axum_server::bind_rustls(addr, config)
+    //     .serve(app.into_make_service())
+    //     .await?;
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{matching::run_match, shares::split_input};
+
+    #[tokio::test]
+    async fn test_match() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        let prover_toml = r#"[user1]
+age = 30
+region = 1
+gender = 0
+id = "0x1fed07ad686a727dfc33b91206d526e61f519dca9c5054ae729231c201717633"
+interests = [2, 4, 6]
+
+[user1.preferences]
+age_max = 35
+age_min = 25
+gender = 1
+
+[user2]
+age = 32
+region = 1
+gender = 1
+id = "0x16e31ced6c74696a601f45f1bb2b9833380d51348fe89644360d0e5abeaf244a"
+interests = [1, 2, 3]
+
+[user2.preferences]
+age_max = 35
+age_min = 25
+gender = 0"#;
+
+        std::fs::write("Prover.toml", prover_toml).unwrap();
+
+        rustls::crypto::aws_lc_rs::default_provider()
+            .install_default()
+            .unwrap();
+
+        let parties = vec![
+            NetworkParty::new(
+                PartyID::ID0.into(),
+                Address::new("localhost".to_string(), 10000),
+                CertificateDer::from(std::fs::read(CONFIG_DIR.join("cert0.der"))?).into_owned(),
+            ),
+            NetworkParty::new(
+                PartyID::ID1.into(),
+                Address::new("localhost".to_string(), 10001),
+                CertificateDer::from(std::fs::read(CONFIG_DIR.join("cert1.der"))?).into_owned(),
+            ),
+            NetworkParty::new(
+                PartyID::ID2.into(),
+                Address::new("localhost".to_string(), 10002),
+                CertificateDer::from(std::fs::read(CONFIG_DIR.join("cert2.der"))?).into_owned(),
+            ),
+        ];
+
+        let program_artifact =
+            Utils::get_program_artifact_from_file(DATA_DIR.join("circuit.json"))?;
+        let constraint_system = Arc::new(Utils::get_constraint_system_from_artifact(
+            &program_artifact,
+            true,
+        ));
+
+        let recursive = true;
+        let has_zk = ZeroKnowledge::No;
+
+        let crs_size = co_noir::compute_circuit_size::<Bn254>(&constraint_system, recursive)?;
+        let crs: (ProverCrs<Bn254>, ark_bn254::G2Affine) = CrsParser::<Bn254>::get_crs(
+            CONFIG_DIR.join("bn254_g1.dat"),
+            CONFIG_DIR.join("bn254_g2.dat"),
+            crs_size,
+            has_zk,
+        )?
+        .split();
+        let prover_crs = Arc::new(crs.0);
+        let verifier_crs = Arc::new(crs.1);
+
+        let shares = split_input(PathBuf::from("Prover.toml"), &program_artifact)?;
+
+        let result = run_match(
+            shares,
+            parties.clone(),
+            &program_artifact,
+            constraint_system.clone(),
+            recursive,
+            has_zk,
+            prover_crs.clone(),
+            verifier_crs.clone(),
+        )
+        .await;
+
+        println!("result: {:?}", result);
+
+        std::fs::remove_file("Prover.toml").unwrap();
+
+        Ok(())
+    }
+}

mpc-server/src/matching.rs

@@ -2,7 +2,7 @@ use co_noir::{
     AcirFormat, Bn254, NetworkConfig, NetworkParty, PartyID, Poseidon2Sponge, Rep3CoUltraHonk,
     Rep3MpcNet, UltraHonk, merge_input_shares,
 };
-use co_ultrahonk::prelude::{Crs, ProverCrs, ZeroKnowledge};
+use co_ultrahonk::prelude::{ProverCrs, ZeroKnowledge};
 use noirc_artifacts::program::ProgramArtifact;
 use once_cell::sync::Lazy;
 use rustls::pki_types::{PrivateKeyDer, PrivatePkcs8KeyDer};
@@ -95,7 +95,7 @@ pub async fn run_matches(
     Ok(())
 }
 
-async fn run_match(
+pub async fn run_match(
     [share0, share1, share2]: [Share; 3],
     parties: Vec<NetworkParty>,
     program_artifact: &ProgramArtifact,
@@ -224,23 +224,26 @@ fn spawn_party(
     let net = Rep3MpcNet::new(network_config)?;
     println!("network setup time: {:?}", start_network.elapsed());
 
-    let start_proof = Instant::now();
+    let total_time = Instant::now();
 
-    // generate witness
+    let witness_time = Instant::now();
     let (witness_share, net) = co_noir::generate_witness_rep3(share, program_artifact, net)?;
+    println!("witness time: {:?}", witness_time.elapsed());
 
-    // generate proving key and vk
+    let pk_time = Instant::now();
     let (pk, net) =
         co_noir::generate_proving_key_rep3(net, &constraint_system, witness_share, recursive)?;
     let vk = pk.create_vk(&prover_crs, *verifier_crs)?;
+    println!("pk time: {:?}", pk_time.elapsed());
 
-    // generate proof
-    let (proof, public_inputs, _) =
-        Rep3CoUltraHonk::<_, _, Poseidon2Sponge>::prove(net, pk, &prover_crs, has_zk)?;
+    let proof_time = Instant::now();
+    // let (proof, _) = Rep3CoUltraHonk::<_, _, Poseidon2Sponge>::prove(net, pk, &prover_crs, has_zk)?;
+    let (proof, _) = Rep3CoUltraHonk::<_, _, Poseidon2Sponge>::prove(net, pk, &prover_crs, has_zk)?;
+    println!("proof time: {:?}", proof_time.elapsed());
 
-    println!("proof time: {:?}", start_proof.elapsed());
+    println!("TOTAL time: {:?}", total_time.elapsed());
 
-    let verified = UltraHonk::<_, Poseidon2Sponge>::verify(proof, &public_inputs, &vk, has_zk)?;
+    let verified = UltraHonk::<_, Poseidon2Sponge>::verify(proof, &vk, has_zk)?;
 
     Ok(verified)
 }

mpc-server/src/shares/split.rs

@@ -4,6 +4,8 @@ use rand::{Rng, distributions::Alphanumeric};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
+use super::Share;
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ProverData {
     user1: User,
@@ -33,8 +35,8 @@ pub async fn split_handler(
     let prover_path1 = save_prover_data(&payload, false)?;
     let prover_path2 = save_prover_data(&payload, true)?;
 
-    let shares1 = split_input(prover_path1, &program_artifact)?;
-    let shares2 = split_input(prover_path2, &program_artifact)?;
+    let shares1 = shares_to_vec_u8(split_input(prover_path1, &program_artifact)?)?;
+    let shares2 = shares_to_vec_u8(split_input(prover_path2, &program_artifact)?)?;
 
     let mut out = shares1
         .iter()
@@ -51,22 +53,25 @@ pub async fn split_handler(
     Ok(out)
 }
 
-fn split_input(
+pub fn split_input(
     input_path: PathBuf,
     program_artifact: &ProgramArtifact,
-) -> Result<Vec<Vec<u8>>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+) -> Result<[Share; 3], Box<dyn std::error::Error + Send + Sync + 'static>> {
     let inputs = co_noir::parse_input(input_path, &program_artifact)?;
 
     let mut rng = rand::thread_rng();
     let shares = co_noir::split_input_rep3::<Bn254, Rep3MpcNet, _>(inputs, &mut rng);
 
-    let out = shares
+    Ok(shares)
+}
+
+fn shares_to_vec_u8(
+    shares: [Share; 3],
+) -> Result<Vec<Vec<u8>>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+    Ok(shares
         .iter()
         .map(|share| bincode::serialize(share))
-        .collect::<Result<Vec<Vec<u8>>, _>>()
-        .unwrap();
-
-    Ok(out)
+        .collect::<Result<Vec<Vec<u8>>, _>>()?)
 }
 
 fn save_prover_data(