respond to RFCs in PR nucypher#48

nucypher-core-python/src/lib.rs

@@ -650,15 +650,20 @@ impl ThresholdDecryptionRequest {
         ciphertext: &[u8], // TODO use ferveo Ciphertext type
         conditions: Option<&Conditions>,
         context: Option<&Context>,
-    ) -> Self {
+    ) -> PyResult<Self> {
         let ferveo_variant: FerveoVariant;
+        if variant > 1 {
+            return Err(PyValueError::new_err(
+                "Invalid ThresholdDecryptionRequest variant",
+            ));
+        }
         match variant {
             0 => ferveo_variant = FerveoVariant::SIMPLE,
             1 => ferveo_variant = FerveoVariant::PRECOMPUTED,
-            _ => panic!("Invalid variant"),
+            _ => unreachable!(),
         }
 
-        Self {
+        Ok(Self {
             backend: nucypher_core::ThresholdDecryptionRequest::new(
                 id,
                 ciphertext,
@@ -668,7 +673,7 @@ impl ThresholdDecryptionRequest {
                 context.map(|context| context.backend.clone()).as_ref(),
                 &ferveo_variant,
             ),
-        }
+        })
     }
 
     #[getter]
@@ -732,7 +737,7 @@ impl ThresholdDecryptionResponse {
     #[new]
     pub fn new(decryption_share: &[u8]) -> Self {
         ThresholdDecryptionResponse {
-            backend: nucypher_core::ThresholdDecryptionResponse::new(decryption_share.into()),
+            backend: nucypher_core::ThresholdDecryptionResponse::new(decryption_share),
         }
     }
 

nucypher-core-wasm/src/lib.rs

@@ -614,11 +614,11 @@ impl ThresholdDecryptionResponse {
     #[wasm_bindgen(constructor)]
     pub fn new(decryption_share: &[u8]) -> Result<ThresholdDecryptionResponse, Error> {
         Ok(Self(nucypher_core::ThresholdDecryptionResponse::new(
-            decryption_share.into(),
+            decryption_share,
         )))
     }
 
-    #[wasm_bindgen(getter)]
+    #[wasm_bindgen(getter, js_name = decryptionShare)]
     pub fn decryption_share(&self) -> Box<[u8]> {
         self.0.decryption_share.clone()
     }

nucypher-core/src/dkg.rs

@@ -2,6 +2,7 @@ use alloc::boxed::Box;
 use alloc::string::String;
 
 use serde::{Deserialize, Serialize};
+use umbral_pre::serde_bytes;
 
 use crate::conditions::{Conditions, Context};
 
@@ -10,7 +11,7 @@ use crate::versioning::{
 };
 
 /// The ferveo variant to use for the decryption share derivation.
-#[derive(PartialEq, Eq, Debug, Serialize, Deserialize, Clone)]
+#[derive(PartialEq, Eq, Debug, Serialize, Deserialize, Copy, Clone)]
 pub enum FerveoVariant {
     /// the simple variant requires n/n shares to decrypt
     SIMPLE,
@@ -24,6 +25,7 @@ pub struct ThresholdDecryptionRequest {
     /// The ID of the ritual.
     pub ritual_id: u16,
     /// The ciphertext to generate a decryption share for.
+    #[serde(with = "serde_bytes::as_base64")]
     pub ciphertext: Box<[u8]>,
     /// A blob of bytes containing decryption conditions for this message.
     pub conditions: Option<Conditions>,
@@ -47,7 +49,7 @@ impl ThresholdDecryptionRequest {
             ciphertext: ciphertext.to_vec().into(),
             conditions: conditions.cloned(),
             context: context.cloned(),
-            variant: variant.clone(),
+            variant: *variant,
         }
     }
 }
@@ -80,13 +82,16 @@ impl<'a> ProtocolObject<'a> for ThresholdDecryptionRequest {}
 #[derive(PartialEq, Eq, Debug, Serialize, Deserialize, Clone)]
 pub struct ThresholdDecryptionResponse {
     /// The decryption share to include in the response.
+    #[serde(with = "serde_bytes::as_base64")]
     pub decryption_share: Box<[u8]>,
 }
 
 impl ThresholdDecryptionResponse {
     /// Creates and a new decryption response.
-    pub fn new(decryption_share: Box<[u8]>) -> Self {
-        ThresholdDecryptionResponse { decryption_share }
+    pub fn new(decryption_share: &[u8]) -> Self {
+        ThresholdDecryptionResponse {
+            decryption_share: decryption_share.to_vec().into(),
+        }
     }
 }
 

nucypher-core/src/node_metadata.rs

@@ -61,6 +61,7 @@ pub struct NodeMetadataPayload {
     /// The node's encrypting key.
     pub encrypting_key: PublicKey,
     /// Ferveo public key to use for DKG participation.
+    #[serde(with = "serde_bytes::as_base64")]
     pub ferveo_public_key: Box<[u8]>, // TODO use ferveo PublicKey?
     /// The node's SSL certificate (serialized in DER format).
     #[serde(with = "serde_bytes::as_base64")]