Added threshold-crypto's 'try_' prefixed constructors.

Cargo.toml

@@ -30,7 +30,7 @@ rand_derive = "0.3.1"
 reed-solomon-erasure = "3.1.0"
 serde = "1.0.55"
 serde_derive = "1.0.55"
-threshold_crypto = { git = "https://github.com/poanetwork/threshold_crypto", tag = "0.1.0" }
+threshold_crypto = { git = "https://github.com/poanetwork/threshold_crypto" }
 tiny-keccak = "1.4"
 
 [dev-dependencies]

examples/network/node.rs

@@ -106,11 +106,8 @@ impl<T: Clone + Debug + AsRef<[u8]> + PartialEq + Send + Sync + From<Vec<u8>> +
         // required by the interface to all algorithms in Honey Badger. Therefore we set placeholder
         // keys here. A fully-featured application would need to take appropriately initialized keys
         // from elsewhere.
-        let secret_key_set =
-            SecretKeySet::from(Poly::zero().expect("Failed to create an empty `Poly`"));
-        let sk_share = secret_key_set
-            .secret_key_share(our_id)
-            .expect("Failed to create our node's `SecretKeyShare`");
+        let secret_key_set = SecretKeySet::from(Poly::zero());
+        let sk_share = secret_key_set.secret_key_share(our_id);
         let pub_key_set = secret_key_set.public_keys();
         let sk = SecretKey::default();
         let pub_keys = all_ids

src/dynamic_honey_badger/builder.rs

@@ -70,9 +70,9 @@ where
     /// Creates a new `DynamicHoneyBadger` configured to start a new network as a single validator.
     pub fn build_first_node(&self, our_id: N) -> Result<(DynamicHoneyBadger<C, N>, Step<C, N>)> {
         let mut rng = rand::thread_rng();
-        let sk_set = SecretKeySet::random(0, &mut rng)?;
+        let sk_set = SecretKeySet::try_random(0, &mut rng)?;
         let pk_set = sk_set.public_keys();
-        let sks = sk_set.secret_key_share(0)?;
+        let sks = sk_set.try_secret_key_share(0)?;
         let sk: SecretKey = rng.gen();
         let pub_keys = once((our_id.clone(), sk.public_key())).collect();
         let netinfo = NetworkInfo::new(our_id, sks, pk_set, sk, pub_keys);

src/messaging.rs

@@ -371,7 +371,7 @@ impl<N: NodeIdT> NetworkInfo<N> {
         let num_faulty = (all_ids.len() - 1) / 3;
 
         // Generate the keys for threshold cryptography.
-        let sk_set = SecretKeySet::random(num_faulty, &mut rng)?;
+        let sk_set = SecretKeySet::try_random(num_faulty, &mut rng)?;
         let pk_set = sk_set.public_keys();
 
         // Generate keys for individually signing and encrypting messages.
@@ -386,7 +386,7 @@ impl<N: NodeIdT> NetworkInfo<N> {
         let create_netinfo = |(i, id): (usize, N)| {
             let netinfo = NetworkInfo::new(
                 id.clone(),
-                sk_set.secret_key_share(i)?,
+                sk_set.try_secret_key_share(i)?,
                 pk_set.clone(),
                 sec_keys[&id].clone(),
                 pub_keys.clone(),

src/sync_key_gen.rs

@@ -63,7 +63,7 @@
 //! let (threshold, node_num) = (1, 4);
 //!
 //! // Generate individual key pairs for encryption. These are not suitable for threshold schemes.
-//! let sec_keys: Vec<SecretKey> = (0..node_num).map(|_| rand::random()).collect();
+//! let sec_keys: Vec<SecretKey> = (0..node_num).map(|_| SecretKey::random()).collect();
 //! let pub_keys: BTreeMap<usize, PublicKey> = sec_keys
 //!     .iter()
 //!     .map(SecretKey::public_key)
@@ -309,10 +309,10 @@ impl<N: NodeIdT> SyncKeyGen<N> {
             return Ok((key_gen, None)); // No part: we are an observer.
         }
         let mut rng = OsRng::new().expect("OS random number generator");
-        let our_part = BivarPoly::random(threshold, &mut rng).map_err(Error::Creation)?;
+        let our_part = BivarPoly::try_random(threshold, &mut rng).map_err(Error::Creation)?;
         let commit = our_part.commitment();
         let encrypt = |(i, pk): (usize, &PublicKey)| {
-            let row = our_part.row(i + 1).map_err(Error::Creation)?;
+            let row = our_part.try_row(i + 1).map_err(Error::Creation)?;
             let bytes = bincode::serialize(&row).expect("failed to serialize row");
             Ok(pk.encrypt(&bytes))
         };
@@ -421,19 +421,19 @@ impl<N: NodeIdT> SyncKeyGen<N> {
     /// All participating nodes must have handled the exact same sequence of `Part` and `Ack`
     /// messages before calling this method. Otherwise their key shares will not match.
     pub fn generate(&self) -> Result<(PublicKeySet, Option<SecretKeyShare>), Error> {
-        let mut pk_commit = Poly::zero().map_err(Error::Generation)?.commitment();
+        let mut pk_commit = Poly::zero().commitment();
         let mut opt_sk_val = self.our_idx.map(|_| Fr::zero());
         let is_complete = |part: &&ProposalState| part.is_complete(self.threshold);
         for part in self.parts.values().filter(is_complete) {
             pk_commit += part.commit.row(0);
             if let Some(sk_val) = opt_sk_val.as_mut() {
-                let row = Poly::interpolate(part.values.iter().take(self.threshold + 1))
+                let row = Poly::try_interpolate(part.values.iter().take(self.threshold + 1))
                     .map_err(Error::Generation)?;
                 sk_val.add_assign(&row.evaluate(0));
             }
         }
         let opt_sk = if let Some(mut fr) = opt_sk_val {
-            let sk = SecretKeyShare::from_mut_ptr(&mut fr as *mut Fr).map_err(Error::Generation)?;
+            let sk = SecretKeyShare::try_from_mut(&mut fr).map_err(Error::Generation)?;
             Some(sk)
         } else {
             None