Clean up

Author: tcerqueira

Cargo.toml

@@ -2,7 +2,7 @@
 members = ["remix", "mix-node"]
 resolver = "2"
 
-[profile.test]
+[profile.dev]
 opt-level = 1
 
 [profile.release]
@@ -13,4 +13,3 @@ panic = "unwind"
 # Speed up compile time checks for sqlx queries
 [profile.dev.package.sqlx-macros]
 opt-level = 3
-# Cm8IuZ8tbGqRIhjR

mix-node/benches/mix_node.rs

@@ -204,25 +204,13 @@ fn bench_serialization_json(c: &mut Criterion) {
         })
     });
 
-    group.bench_function("to value", |b| {
-        b.iter(|| {
-            let _value = serde_json::to_value(&payload);
-        })
-    });
-
     let payload = payload_subset(&payload, 0..N_SMALL_BITS);
 
     group.bench_function(f!("to string {N_SMALL_BITS} bits subset"), |b| {
         b.iter(|| {
             let _string = serde_json::to_string(&payload);
         })
     });
-
-    group.bench_function(f!("to value {N_SMALL_BITS} bits subset"), |b| {
-        b.iter(|| {
-            let _value = serde_json::to_value(&payload);
-        })
-    });
 }
 
 fn bench_deserialization_json(c: &mut Criterion) {
@@ -263,7 +251,7 @@ pub fn decrypt_bits<'a>(
     pk: &'a SecretKey<Ristretto>,
 ) -> impl Iterator<Item = bool> + 'a {
     ct.iter().map(|ct| {
-        let point = pk.decrypt(*ct, &DiscreteLogTable::new(0..2)).unwrap();
+        let point = pk.decrypt(*ct, &DiscreteLogTable::new(0..=1)).unwrap();
         point != 0u64
     })
 }

mix-node/src/bin/lambda.rs

@@ -1,9 +1,3 @@
-use std::net::SocketAddr;
-
-use axum::{extract::ConnectInfo, Router};
-use lambda_http::tower::util::MapRequest;
-use lambda_http::RequestExt;
-use lambda_http::{http::Request, request::RequestContext};
 use mix_node::{
     config::{self, Config},
     db, rest, AppState,
@@ -32,32 +26,5 @@ async fn main() -> Result<(), lambda_http::Error> {
 
     let conn = db::connect_database(db_config);
     let state = AppState::new(app_config.auth_token, conn, crypto_config);
-    lambda_http::run(
-        rest::app(state).layer(MapRequest::<Router, _>::layer(extract_lambda_source_ip)),
-    )
-    .await
-}
-
-fn extract_lambda_source_ip<B>(mut request: Request<B>) -> Request<B> {
-    if request
-        .extensions()
-        .get::<ConnectInfo<SocketAddr>>()
-        .is_some()
-    {
-        return request;
-    }
-
-    let Some(RequestContext::ApiGatewayV2(cx)) = request.request_context_ref() else {
-        return request;
-    };
-
-    let Some(source_ip) = &cx.http.source_ip else {
-        return request;
-    };
-
-    if let Ok(addr) = source_ip.parse::<SocketAddr>() {
-        request.extensions_mut().insert(ConnectInfo(addr));
-    }
-
-    request
+    lambda_http::run(rest::app(state)).await
 }

mix-node/src/crypto.rs

@@ -27,7 +27,6 @@ impl DecryptionShare {
     }
 }
 
-// TODO: lookup table can be just 0..1 in prod
 pub static LOOKUP_TABLE: LazyLock<DiscreteLogTable<Ristretto>> =
     LazyLock::new(|| DiscreteLogTable::<Ristretto>::new(0..=1));
 
@@ -86,7 +85,6 @@ pub fn decryption_share_for(
     DecryptionShare::new(active_participant.index(), share)
 }
 
-// PERF: parallelize this
 pub fn decrypt_shares(
     key_set: &PublicKeySet<Ristretto>,
     enc: &[Ciphertext],
@@ -121,6 +119,7 @@ pub fn decrypt_shares(
                 .context("decrypted values out of range of lookup table")?
                 == 1u64)
         })
+        // PERF: collect directly to BitVec
         .collect::<anyhow::Result<Vec<_>>>()
         .map(Bits::from_iter)
 }

mix-node/src/rest/error.rs

@@ -18,10 +18,7 @@ impl IntoResponse for Error {
     fn into_response(self) -> Response {
         let status_code = match &self {
             Error::InvalidLength(_) => StatusCode::BAD_REQUEST,
-            Error::Unexpected(_) => {
-                tracing::error!("{self:?}");
-                StatusCode::INTERNAL_SERVER_ERROR
-            }
+            Error::Unexpected(_) => StatusCode::INTERNAL_SERVER_ERROR,
         };
         (status_code, self.to_string()).into_response()
     }

mix-node/src/rest/routes.rs

@@ -97,17 +97,14 @@ pub async fn hamming_distance(
     // Remix
     tracing::trace!("remix self");
     let (mut x_code, mut y_code) = {
-        let inner_state = Arc::clone(&state);
+        let state = Arc::clone(&state);
         rokio::spawn(move || -> Result<_, CryptoError> {
-            crypto::remix(
-                &mut x_code,
-                &mut y_code,
-                inner_state.pub_key_set().shared_key(),
-            )?;
+            crypto::remix(&mut x_code, &mut y_code, state.pub_key_set().shared_key())?;
             Ok((x_code, y_code))
         })
         .await?
     };
+    // This algorithm runs serially and it's not fast to serialize and deserialize 2*25600 bits
     tracing::trace!("remix participants");
     for node in &state.crypto.participants {
         (x_code, y_code) = request_remix(
@@ -120,23 +117,30 @@ pub async fn hamming_distance(
         .unwrap_or((x_code, y_code));
         tracing::trace!(id = ?node, "remix participant");
     }
-    let (x_code, y_code) = (Arc::new(x_code), Arc::new(y_code));
+
+    let x_code = Arc::new(x_code);
+    let y_code = Arc::new(y_code);
 
     // Decrypt
     tracing::trace!("request shares");
     let (x_shares, y_shares) = {
-        let (x_state, y_state) = (Arc::clone(&state), Arc::clone(&state));
         let (x_inner_code, y_inner_code) = (Arc::clone(&x_code), Arc::clone(&y_code));
 
         let (mut x_shares, mut y_shares, x_self_share, y_self_share) = tokio::join!(
             request_all_shares(&x_code, &state),
             request_all_shares(&y_code, &state),
-            rokio::spawn(move || {
-                crypto::decryption_share_for(&x_state.crypto.active_participant, &x_inner_code)
-            }),
-            rokio::spawn(move || {
-                crypto::decryption_share_for(&y_state.crypto.active_participant, &y_inner_code)
-            })
+            {
+                let state = Arc::clone(&state);
+                rokio::spawn(move || {
+                    crypto::decryption_share_for(&state.crypto.active_participant, &x_inner_code)
+                })
+            },
+            {
+                let state = Arc::clone(&state);
+                rokio::spawn(move || {
+                    crypto::decryption_share_for(&state.crypto.active_participant, &y_inner_code)
+                })
+            }
         );
         x_shares.push(x_self_share);
         y_shares.push(y_self_share);