🚧 Wip

git log

examples/bin_test_groth16.rs

@@ -1,4 +1,4 @@
-use mpc_net::{MpcMultiNet as Net, MpcNet};
+use mpc_net::{LocalTestNet as Net, MPCNet};
 use std::path::PathBuf;
 use structopt::StructOpt;
 

examples/bin_test_marlin.rs

@@ -1,4 +1,4 @@
-use mpc_net::{MpcMultiNet as Net, MpcNet};
+use mpc_net::{LocalTestNet as Net, MPCNet};
 use std::path::PathBuf;
 use structopt::StructOpt;
 

examples/online.rs

@@ -5,7 +5,8 @@ use ark_marlin::IndexProverKey;
 use ark_serialize::{CanonicalDeserialize, Read};
 use ark_std::test_rng;
 use mpc_algebra::Reveal;
-use mpc_net::{MpcMultiNet as Net, MpcNet};
+use mpc_net::{LocalTestNet as Net, MPCNet};
+
 use serde::Deserialize;
 use std::{fs::File, path::PathBuf, vec};
 use structopt::StructOpt;

mpc-algebra/examples/algebra.rs

@@ -73,7 +73,7 @@ fn test_div() {
 }
 
 fn test_sum() {
-    let a = [
+    let a = vec![
         MF::from_public(F::from(1u64)),
         MF::from_public(F::from(2u64)),
         MF::from_public(F::from(3u64)),

mpc-algebra/src/channel.rs

@@ -1,26 +1,29 @@
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
-use mpc_net::MpcNet;
+use mpc_net::MPCNet;
 use rand::RngCore;
 use sha2::{Digest, Sha256};
 use std::cell::Cell;
 
 /// A trait for MPC networks that can serialize and deserialize.
-pub trait MpcSerNet: MpcNet {
+pub trait MPCSerNet: MPCNet {
     /// Broadcast a value to each other.
-    fn broadcast<T: CanonicalSerialize + CanonicalDeserialize>(out: &T) -> Vec<T> {
+    fn broadcast<T: CanonicalSerialize + CanonicalDeserialize>(&self, out: &T) -> Vec<T> {
         let mut bytes_out = Vec::new();
         out.serialize(&mut bytes_out).unwrap();
-        let bytes_in = Self::broadcast_bytes(&bytes_out);
+        let bytes_in = self.broadcast(&bytes_out);
         bytes_in
             .into_iter()
             .map(|b| T::deserialize(&b[..]).unwrap())
             .collect()
     }
 
-    fn send_to_king<T: CanonicalDeserialize + CanonicalSerialize>(out: &T) -> Option<Vec<T>> {
+    fn send_to_king<T: CanonicalDeserialize + CanonicalSerialize>(
+        &self,
+        out: &T,
+    ) -> Option<Vec<T>> {
         let mut bytes_out = Vec::new();
         out.serialize(&mut bytes_out).unwrap();
-        Self::send_bytes_to_king(&bytes_out).map(|bytes_in| {
+        self.send_to_king(&bytes_out).map(|bytes_in| {
             bytes_in
                 .into_iter()
                 .map(|b| T::deserialize(&b[..]).unwrap())
@@ -41,20 +44,20 @@ pub trait MpcSerNet: MpcNet {
         T::deserialize(&bytes_in[..]).unwrap()
     }
 
-    fn atomic_broadcast<T: CanonicalDeserialize + CanonicalSerialize>(out: &T) -> Vec<T> {
+    fn atomic_broadcast<T: CanonicalDeserialize + CanonicalSerialize>(&self, out: &T) -> Vec<T> {
         let mut bytes_out = Vec::new();
         out.serialize(&mut bytes_out).unwrap();
         let ser_len = bytes_out.len();
         bytes_out.resize(ser_len + COMMIT_RAND_BYTES, 0);
         rand::thread_rng().fill_bytes(&mut bytes_out[ser_len..]);
-        let commitment = CommitHash::new().chain(&bytes_out).finalize();
-        // exchange commitments
-        let all_commits = Self::broadcast_bytes(&commitment[..]);
-        // exchange (data || randomness)
-        let all_data = Self::broadcast_bytes(&bytes_out);
-        let self_id = Self::party_id();
+        let commitment = CommitHash::new().chain(&bytes_out).finalize().to_vec();
+        // コミットメントを交換
+        let all_commits = self.broadcast(&commitment);
+        // データとランダムネスを交換
+        let all_data = self.broadcast(&bytes_out);
+        let self_id = self.party_id();
         for i in 0..all_commits.len() {
-            if i != self_id {
+            if i as u32 != self_id {
                 // check other commitment
                 assert_eq!(
                     &all_commits[i][..],
@@ -69,15 +72,15 @@ pub trait MpcSerNet: MpcNet {
     }
 
     fn king_compute<T: CanonicalDeserialize + CanonicalSerialize>(
+        &self,
         x: &T,
         f: impl Fn(Vec<T>) -> Vec<T>,
     ) -> T {
         let king_response = Self::send_to_king(x).map(f);
         Self::receive_from_king(king_response)
     }
 }
-
-impl<N: MpcNet> MpcSerNet for N {}
+impl<N: MPCNet> MPCSerNet for N {}
 
 const ALLOW_CHEATING: Cell<bool> = Cell::new(true);
 

mpc-algebra/src/share/additive.rs

@@ -3,6 +3,7 @@ use std::fmt::{self, Debug, Display, Formatter};
 use std::hash::Hash;
 use std::io::{self, Read, Write};
 use std::marker::PhantomData;
+use std::sync::{Arc, Mutex};
 
 use ark_ec::{group::Group, PairingEngine, ProjectiveCurve};
 use ark_ff::BigInteger;
@@ -19,8 +20,8 @@ use rand::Rng;
 use crate::reveal::Reveal;
 use crate::{BeaverSource, DenseOrSparsePolynomial, DensePolynomial, Msm, SparsePolynomial};
 
-use crate::channel::MpcSerNet;
-use mpc_net::{MpcMultiNet as Net, MpcNet};
+use crate::channel::MPCSerNet;
+use mpc_net::LocalTestNet as Net;
 
 // use super::pairing::ExtendedPairingEngine;
 // use super::group::GroupAffineShare;
@@ -30,9 +31,11 @@ use super::{
     pairing::{AffProjShare, PairingShare},
 };
 
-#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct AdditiveFieldShare<T> {
     pub val: T,
+    // reference to Net
+    net: Arc<Mutex<Net>>,
 }
 
 impl<F: Field> AdditiveFieldShare<F> {
@@ -78,21 +81,22 @@ impl<F: Field> AdditiveFieldShare<F> {
 impl<F: Field> Reveal for AdditiveFieldShare<F> {
     type Base = F;
 
-    fn reveal(self) -> Self::Base {
-        Net::broadcast(&self.val).into_iter().sum()
+    fn reveal(&self) -> Self::Base {
+        self.net.broadcast(&self.val).into_iter().sum()
     }
 
-    fn from_add_shared(b: Self::Base) -> Self {
-        Self { val: b }
+    fn from_add_shared(b: Self::Base, net: Net) -> Self {
+        Self { val: b, net }
     }
 
-    fn from_public(f: Self::Base) -> Self {
+    fn from_public(f: Self::Base,  net: Net) -> Self {
         Self {
-            val: if Net::am_king() { f } else { F::zero() },
+            val: if net. { f } else { F::zero() },
+            net: self.net.clone(),
         }
     }
 
-    fn unwrap_as_public(self) -> Self::Base {
+    fn unwrap_as_public(&self) -> Self::Base {
         self.val
     }
     fn king_share<R: Rng>(f: Self::Base, rng: &mut R) -> Self {
@@ -239,14 +243,16 @@ macro_rules! impl_field_basics {
 
 impl_field_basics!(AdditiveFieldShare, Field);
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub struct AdditiveExtFieldShare<F: Field>(pub PhantomData<F>);
 
 impl<F: Field> ExtFieldShare<F> for AdditiveExtFieldShare<F> {
     type Base = AdditiveFieldShare<F::BasePrimeField>;
     type Ext = AdditiveFieldShare<F>;
 }
 
+impl Copy for AdditiveExtFieldShare<crate::field::Fp> {}
+
 #[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct MulFieldShare<T> {
     pub val: T,

mpc-algebra/src/share/spdz.rs

@@ -16,8 +16,8 @@ use std::hash::Hash;
 use std::io::{self, Read, Write};
 use std::marker::PhantomData;
 
-use crate::channel::{can_cheat, MpcSerNet};
-use mpc_net::{MpcMultiNet as Net, MpcNet};
+use crate::channel::{can_cheat, MPCSerNet};
+use mpc_net::{LocalTestNet as Net, MPCNet};
 
 use super::additive::{AdditiveFieldShare, AdditiveGroupShare, MulFieldShare};
 use super::field::{DenseOrSparsePolynomial, DensePolynomial, ExtFieldShare, FieldShare};
@@ -46,7 +46,7 @@ pub fn mac<F: Field>() -> F {
     }
 }
 
-#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct SpdzFieldShare<T> {
     sh: AdditiveFieldShare<T>,
     mac: AdditiveFieldShare<T>,

mpc-algebra/src/wire/edwards.rs

@@ -10,10 +10,10 @@ use ark_crypto_primitives::commitment::pedersen::{Parameters, Randomness};
 use ark_crypto_primitives::encryption::elgamal::Parameters as ElGamalParameters;
 use ark_crypto_primitives::encryption::elgamal::Randomness as ElGamalRandomness;
 
-use mpc_net::MpcMultiNet as Net;
+use mpc_net::LocalTestNet as Net;
 use mpc_trait::MpcWire;
 
-use crate::{channel::MpcSerNet, SpdzFieldShare};
+use crate::{channel::MPCSerNet, SpdzFieldShare};
 use crate::{AdditiveFieldShare, MpcField, Reveal};
 
 type AdditiveFq = MpcField<ark_bls12_377::Fr, AdditiveFieldShare<ark_bls12_377::Fr>>;

mpc-algebra/src/wire/field.rs

@@ -29,7 +29,7 @@ use crate::{
     LogicalOperations, Reveal,
 };
 use crate::{EqualityZero, UniformBitRand};
-use mpc_net::{MpcMultiNet as Net, MpcNet};
+use mpc_net::{LocalTestNet as Net, MPCNet};
 
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub enum MpcField<F: Field, S: FieldShare<F>> {

mpc-algebra/src/wire/macros.rs

@@ -1,21 +1,21 @@
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 
-use crate::channel::MpcSerNet;
-use mpc_net::MpcNet;
+use crate::channel::MPCSerNet;
+use mpc_net::MPCNet;
 
 use std::fmt::Display;
 
 pub fn check_eq<T: CanonicalSerialize + CanonicalDeserialize + Clone + Eq + Display>(t: T) {
     debug_assert!({
         use log::debug;
         debug!("Consistency check");
-        let others = mpc_net::MpcMultiNet::broadcast(&t);
+        let others = mpc_net::LocalTestNet::broadcast(&t);
         let mut result = true;
         for (i, other_t) in others.iter().enumerate() {
             if &t != other_t {
                 println!(
                     "\nConsistency check failed\nI (party {}) have {}\nvs\n  (party {}) has  {}",
-                    mpc_net::MpcMultiNet::party_id(),
+                    mpc_net::LocalTestNet::party_id(),
                     t,
                     i,
                     other_t