Convert to 2018 edition (#51)

Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "curv"
 version = "0.1.0"
+edition = "2018"
 
 
 [lib]

examples/diffie_hellman_key_exchange.rs

@@ -1,5 +1,3 @@
-extern crate curv;
-
 /// Diffie Hellman Key Exchange:
 /// TO RUN:
 /// cargo run --example diffie_hellman_key_exchange --features CURVE_NAME

examples/pedersen_commitment.rs

@@ -1,5 +1,3 @@
-extern crate curv;
-
 use curv::BigInt;
 
 /// Pedesen Commitment:

examples/proof_of_knowledge_of_dlog.rs

@@ -1,5 +1,3 @@
-extern crate curv;
-
 /// Sigma protocol for proof of knowledge of discrete log
 /// TO RUN:
 /// cargo run --example proof_of_knowledge_of_dlog --features CURVE_NAME

examples/verifiable_secret_sharing.rs

@@ -1,5 +1,3 @@
-extern crate curv;
-
 /// secret_sharing_3_out_of_5
 /// Feldman VSS, based on  Paul Feldman. 1987. A practical scheme for non-interactive verifiable secret sharing.
 /// In Foundations of Computer Science, 1987., 28th Annual Symposium on.IEEE, 427–43

src/arithmetic/big_gmp.rs

@@ -1,5 +1,3 @@
-#![cfg(feature="rust-gmp")]
-
 /*
     Curv
 
@@ -16,12 +14,12 @@
     @license GPL-3.0+ <https://github.com/KZen-networks/curv/blob/master/LICENSE>
 */
 
-use super::gmp::mpz::Mpz;
 use super::rand::rngs::OsRng;
 use super::rand::RngCore;
 use super::traits::{
     BitManipulation, ConvertFrom, Converter, Modulo, NumberTests, Samplable, ZeroizeBN, EGCD,
 };
+use gmp::mpz::Mpz;
 
 use std::borrow::Borrow;
 use std::ptr;

src/arithmetic/mod.rs

@@ -14,11 +14,10 @@
     @license GPL-3.0+ <https://github.com/KZen-networks/cryptography-utils/blob/master/LICENSE>
 */
 
-#[cfg(feature = "rust-gmp")]
-extern crate gmp;
-extern crate rand;
+use rand;
 
 const HEX_RADIX: u8 = 16;
 
+#[cfg(feature = "rust-gmp")]
 pub mod big_gmp;
 pub mod traits;

src/arithmetic/traits.rs

@@ -42,8 +42,8 @@ pub trait Samplable {
 }
 
 pub trait NumberTests {
-    fn is_zero(&Self) -> bool;
-    fn is_even(&Self) -> bool;
+    fn is_zero(_: &Self) -> bool;
+    fn is_even(_: &Self) -> bool;
     fn is_negative(me: &Self) -> bool;
 }
 
@@ -60,6 +60,6 @@ pub trait BitManipulation {
 }
 
 pub trait ConvertFrom<T> {
-    fn _from(&T) -> Self;
+    fn _from(_: &T) -> Self;
 }
 //use std::ops::{Add, Div, Mul, Neg, Rem, Shr, Sub};

src/cryptographic_primitives/commitments/hash_commitment.rs

@@ -10,11 +10,11 @@
 /// r is 256bit blinding factor, m is the commited value
 pub struct HashCommitment;
 
-use BigInt;
+use crate::BigInt;
 
 use super::traits::Commitment;
 use super::SECURITY_BITS;
-use arithmetic::traits::Samplable;
+use crate::arithmetic::traits::Samplable;
 use sha3::{Digest, Sha3_256};
 //TODO:  using the function with BigInt's as input instead of string's makes it impossible to commit to empty message or use empty randomness
 impl Commitment<BigInt> for HashCommitment {
@@ -45,9 +45,9 @@ mod tests {
     use super::Commitment;
     use super::HashCommitment;
     use super::SECURITY_BITS;
-    use arithmetic::traits::Samplable;
+    use crate::arithmetic::traits::Samplable;
+    use crate::BigInt;
     use sha3::{Digest, Sha3_256};
-    use BigInt;
 
     #[test]
     fn test_bit_length_create_commitment() {

src/cryptographic_primitives/commitments/pedersen_commitment.rs

@@ -7,10 +7,10 @@
 
 use super::traits::Commitment;
 use super::SECURITY_BITS;
-use arithmetic::traits::Samplable;
+use crate::arithmetic::traits::Samplable;
 
-use elliptic::curves::traits::*;
-use {BigInt, FE, GE};
+use crate::elliptic::curves::traits::*;
+use crate::{BigInt, FE, GE};
 
 /// compute c = mG + rH
 /// where m is the commited value, G is the group generator,

src/cryptographic_primitives/commitments/traits.rs

@@ -5,7 +5,7 @@
     License MIT: https://github.com/KZen-networks/curv/blob/master/LICENSE
 */
 
-use BigInt;
+use crate::BigInt;
 
 pub trait Commitment<T> {
     fn create_commitment_with_user_defined_randomness(

src/cryptographic_primitives/hashing/blake2b512.rs

@@ -4,10 +4,10 @@
     (https://github.com/KZen-networks/curv)
     License MIT: https://github.com/KZen-networks/curv/blob/master/LICENSE
 */
-use arithmetic::traits::Converter;
+use crate::arithmetic::traits::Converter;
+use crate::elliptic::curves::traits::{ECPoint, ECScalar};
+use crate::{BigInt, FE, GE};
 use blake2b_simd::Params;
-use elliptic::curves::traits::{ECPoint, ECScalar};
-use {BigInt, FE, GE};
 
 pub struct Blake;
 
@@ -38,10 +38,10 @@ impl Blake {
 #[cfg(test)]
 mod tests {
     use super::Blake;
-    use elliptic::curves::traits::ECPoint;
-    use elliptic::curves::traits::ECScalar;
-    use BigInt;
-    use GE;
+    use crate::elliptic::curves::traits::ECPoint;
+    use crate::elliptic::curves::traits::ECScalar;
+    use crate::BigInt;
+    use crate::GE;
 
     #[test]
     // Very basic test here, TODO: suggest better testing

src/cryptographic_primitives/hashing/hash_sha256.rs

@@ -6,14 +6,14 @@
 */
 
 use super::traits::Hash;
-use arithmetic::traits::Converter;
+use crate::arithmetic::traits::Converter;
+use crate::elliptic::curves::traits::{ECPoint, ECScalar};
 use crypto::digest::Digest;
 use crypto::sha2::Sha256;
-use elliptic::curves::traits::{ECPoint, ECScalar};
 use hex::decode;
 
-use BigInt;
-use {FE, GE};
+use crate::BigInt;
+use crate::{FE, GE};
 
 pub struct HSha256;
 
@@ -49,10 +49,10 @@ impl Hash for HSha256 {
 mod tests {
     use super::HSha256;
     use super::Hash;
-    use elliptic::curves::traits::ECPoint;
-    use elliptic::curves::traits::ECScalar;
-    use BigInt;
-    use GE;
+    use crate::elliptic::curves::traits::ECPoint;
+    use crate::elliptic::curves::traits::ECScalar;
+    use crate::BigInt;
+    use crate::GE;
 
     #[test]
     // Test Vectors taken from:

src/cryptographic_primitives/hashing/hash_sha512.rs

@@ -6,14 +6,14 @@
 */
 
 use super::traits::Hash;
-use arithmetic::traits::Converter;
+use crate::arithmetic::traits::Converter;
+use crate::elliptic::curves::traits::{ECPoint, ECScalar};
 use crypto::digest::Digest;
 use crypto::sha2::Sha512;
-use elliptic::curves::traits::{ECPoint, ECScalar};
 use hex::decode;
 
-use BigInt;
-use {FE, GE};
+use crate::BigInt;
+use crate::{FE, GE};
 
 pub struct HSha512;
 
@@ -49,10 +49,10 @@ impl Hash for HSha512 {
 mod tests {
     use super::HSha512;
     use super::Hash;
-    use elliptic::curves::traits::ECPoint;
-    use elliptic::curves::traits::ECScalar;
-    use BigInt;
-    use GE;
+    use crate::elliptic::curves::traits::ECPoint;
+    use crate::elliptic::curves::traits::ECScalar;
+    use crate::BigInt;
+    use crate::GE;
 
     #[test]
     // Test Vectors taken from:

src/cryptographic_primitives/hashing/hmac_sha512.rs

@@ -5,10 +5,10 @@
     License MIT: https://github.com/KZen-networks/curv/blob/master/LICENSE
 */
 
-use BigInt;
+use crate::BigInt;
 
 use super::traits::KeyedHash;
-use arithmetic::traits::Converter;
+use crate::arithmetic::traits::Converter;
 
 use crypto::hmac::Hmac;
 use crypto::mac::Mac;
@@ -37,9 +37,9 @@ impl KeyedHash for HMacSha512 {
 mod tests {
 
     use super::HMacSha512;
-    use arithmetic::traits::Samplable;
-    use cryptographic_primitives::hashing::traits::KeyedHash;
-    use BigInt;
+    use crate::arithmetic::traits::Samplable;
+    use crate::cryptographic_primitives::hashing::traits::KeyedHash;
+    use crate::BigInt;
 
     #[test]
     fn create_hmac_test() {

src/cryptographic_primitives/hashing/merkle_tree.rs

@@ -8,8 +8,8 @@
 use crypto::sha3::Sha3;
 use merkle::{MerkleTree, Proof};
 
-use elliptic::curves::traits::ECPoint;
-use GE;
+use crate::elliptic::curves::traits::ECPoint;
+use crate::GE;
 /*
 pub struct MT256<'a> {
     tree: MerkleTree<GE>,
@@ -58,9 +58,9 @@ impl MT256 {
 
 #[cfg(test)]
 mod tests {
-    use cryptographic_primitives::hashing::merkle_tree::MT256;
-    use elliptic::curves::traits::ECPoint;
-    use GE;
+    use crate::cryptographic_primitives::hashing::merkle_tree::MT256;
+    use crate::elliptic::curves::traits::ECPoint;
+    use crate::GE;
     #[test]
     fn test_mt_functionality_four_leaves() {
         let ge1: GE = ECPoint::generator();

src/cryptographic_primitives/hashing/traits.rs

@@ -5,8 +5,8 @@
     License MIT: https://github.com/KZen-networks/curv/blob/master/LICENSE
 */
 
-use BigInt;
-use {FE, GE};
+use crate::BigInt;
+use crate::{FE, GE};
 
 pub trait Hash {
     fn create_hash(big_ints: &[&BigInt]) -> BigInt;

src/cryptographic_primitives/proofs/sigma_correct_homomorphic_elgamal_enc.rs

@@ -7,12 +7,12 @@
 */
 
 use super::ProofError;
-use cryptographic_primitives::hashing::hash_sha256::HSha256;
-use cryptographic_primitives::hashing::traits::Hash;
-use elliptic::curves::traits::*;
+use crate::cryptographic_primitives::hashing::hash_sha256::HSha256;
+use crate::cryptographic_primitives::hashing::traits::Hash;
+use crate::elliptic::curves::traits::*;
+use crate::FE;
+use crate::GE;
 use zeroize::Zeroize;
-use FE;
-use GE;
 
 /// This is a proof of knowledge that a pair of group elements {D, E}
 /// form a valid homomorphic ElGamal encryption (”in the exponent”) using public key Y .
@@ -81,8 +81,8 @@ impl HomoELGamalProof {
 
 #[cfg(test)]
 mod tests {
-    use cryptographic_primitives::proofs::sigma_correct_homomorphic_elgamal_enc::*;
-    use {FE, GE};
+    use crate::cryptographic_primitives::proofs::sigma_correct_homomorphic_elgamal_enc::*;
+    use crate::{FE, GE};
 
     #[test]
     fn test_correct_general_homo_elgamal() {

src/cryptographic_primitives/proofs/sigma_correct_homomorphic_elgamal_encryption_of_dlog.rs

@@ -7,12 +7,12 @@
 */
 
 use super::ProofError;
-use cryptographic_primitives::hashing::hash_sha256::HSha256;
-use cryptographic_primitives::hashing::traits::Hash;
-use elliptic::curves::traits::*;
+use crate::cryptographic_primitives::hashing::hash_sha256::HSha256;
+use crate::cryptographic_primitives::hashing::traits::Hash;
+use crate::elliptic::curves::traits::*;
+use crate::FE;
+use crate::GE;
 use zeroize::Zeroize;
-use FE;
-use GE;
 
 /// This is a proof of knowledge that a pair of group elements {D, E}
 /// form a valid homomorphic ElGamal encryption (”in the exponent”) using public key Y .
@@ -84,8 +84,8 @@ impl HomoELGamalDlogProof {
 
 #[cfg(test)]
 mod tests {
-    use cryptographic_primitives::proofs::sigma_correct_homomorphic_elgamal_encryption_of_dlog::*;
-    use {FE, GE};
+    use crate::cryptographic_primitives::proofs::sigma_correct_homomorphic_elgamal_encryption_of_dlog::*;
+    use crate::{FE, GE};
 
     #[test]
     fn test_correct_homo_elgamal() {

src/cryptographic_primitives/proofs/sigma_dlog.rs

@@ -6,13 +6,13 @@
 */
 
 use super::ProofError;
-use FE;
-use GE;
+use crate::FE;
+use crate::GE;
 
-use elliptic::curves::traits::*;
+use crate::elliptic::curves::traits::*;
 
-use cryptographic_primitives::hashing::hash_sha256::HSha256;
-use cryptographic_primitives::hashing::traits::Hash;
+use crate::cryptographic_primitives::hashing::hash_sha256::HSha256;
+use crate::cryptographic_primitives::hashing::traits::Hash;
 use zeroize::Zeroize;
 
 /// This is implementation of Schnorr's identification protocol for elliptic curve groups or a
@@ -90,8 +90,8 @@ impl ProveDLog for DLogProof {
 
 #[cfg(test)]
 mod tests {
-    use cryptographic_primitives::proofs::sigma_dlog::*;
-    use FE;
+    use crate::cryptographic_primitives::proofs::sigma_dlog::*;
+    use crate::FE;
 
     #[test]
     fn test_dlog_proof() {