merge

ipa-core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "ipa-core"
 version = "0.1.0"
-rust-version = "1.64.0"
+rust-version = "1.75.0"
 edition = "2021"
 
 [features]

ipa-core/src/cli/playbook/ipa.rs

@@ -213,7 +213,11 @@ where
         .unwrap();
 
     let results: Vec<F> = results
-        .map(|bytes| AdditiveShare::<F>::from_byte_slice(&bytes).collect::<Vec<_>>())
+        .map(|bytes| {
+            AdditiveShare::<F>::from_byte_slice(&bytes)
+                .collect::<Result<Vec<_>, _>>()
+                .unwrap()
+        })
         .reconstruct();
 
     let lat = mpc_time.elapsed();

ipa-core/src/cli/playbook/multiply.rs

@@ -73,6 +73,10 @@ where
 
     // expect replicated shares to be sent back
     results
-        .map(|bytes| Replicated::<F>::from_byte_slice(&bytes).collect::<Vec<_>>())
+        .map(|bytes| {
+            Replicated::<F>::from_byte_slice(&bytes)
+                .collect::<Result<Vec<_>, _>>()
+                .unwrap()
+        })
         .reconstruct()
 }

ipa-core/src/error.rs

@@ -1,4 +1,4 @@
-use std::{backtrace::Backtrace, fmt::Debug};
+use std::{backtrace::Backtrace, convert::Infallible, fmt::Debug};
 
 use thiserror::Error;
 
@@ -108,3 +108,23 @@ pub fn set_global_panic_hook() {
         (default_hook)(panic_info);
     }));
 }
+
+/// Same purpose as [`unwrap-infallible`] but fewer dependencies.
+/// As usual, there is a 8 year old [`RFC`] to make this to std that hasn't been merged yet.
+///
+/// [`unwrap-infallible`]: https://docs.rs/unwrap-infallible/latest/unwrap_infallible
+/// [`RFC`]: https://github.com/rust-lang/rfcs/issues/1723
+pub trait UnwrapInfallible {
+    /// R to avoid clashing with result's `Ok` type.
+    type R;
+
+    fn unwrap_infallible(self) -> Self::R;
+}
+
+impl<T> UnwrapInfallible for Result<T, Infallible> {
+    type R = T;
+
+    fn unwrap_infallible(self) -> Self::R {
+        self.unwrap()
+    }
+}

ipa-core/src/ff/boolean.rs

@@ -37,18 +37,23 @@ impl From<Boolean> for bool {
     }
 }
 
+#[derive(thiserror::Error, Debug)]
+#[error("{0} is not a valid boolean value, only 0 and 1 are accepted.")]
+pub struct ParseBooleanError(u8);
+
 impl Serializable for Boolean {
     type Size = <<Boolean as SharedValue>::Storage as Block>::Size;
+    type DeserializationError = ParseBooleanError;
 
     fn serialize(&self, buf: &mut GenericArray<u8, Self::Size>) {
         buf[0] = u8::from(self.0);
     }
 
-    ///## Panics
-    /// panics when u8 is not 0 or 1
-    fn deserialize(buf: &GenericArray<u8, Self::Size>) -> Self {
-        assert!(buf[0] < 2u8);
-        Boolean(buf[0] != 0)
+    fn deserialize(buf: &GenericArray<u8, Self::Size>) -> Result<Self, Self::DeserializationError> {
+        if buf[0] > 1 {
+            return Err(ParseBooleanError(buf[0]));
+        }
+        Ok(Boolean(buf[0] != 0))
     }
 }
 
@@ -180,7 +185,7 @@ mod test {
         let input = rng.gen::<Boolean>();
         let mut a: GenericArray<u8, U1> = [0u8; 1].into();
         input.serialize(&mut a);
-        let output = Boolean::deserialize(&a);
+        let output = Boolean::deserialize(&a).unwrap();
         assert_eq!(input, output);
     }