Update k256 to 0.5 (#13)

Author: vorot93

Cargo.toml

@@ -24,9 +24,9 @@ rlp = "0.4.5"
 tiny-keccak = { version = "2.0.2", features = ["keccak"] }
 zeroize = "1.1.0"
 libsecp256k1 = { version = "0.3.5", optional = true }
-ecdsa = { version = "0.7", optional = true }
+ecdsa = { version = "0.8", optional = true }
 sha3 = { version = "0.9", optional = true }
-k256-crate = { package = "k256", version = "0.4", features = ["ecdsa"], optional = true }
+k256-crate = { package = "k256", version = "0.5", features = ["ecdsa"], optional = true }
 serde = { version = "1.0.110", optional = true }
 ed25519-dalek = { version = "1.0.0-pre.4", optional = true }
 c-secp256k1 = { package = "secp256k1", version = "0.17.2", optional = true }

src/keys/k256.rs

@@ -2,39 +2,34 @@
 
 use super::{EnrKey, EnrPublicKey, SigningError};
 use crate::Key;
-use k256_crate::{
-    ecdsa::signature::{DigestVerifier, RandomizedDigestSigner, Signature},
-    elliptic_curve::weierstrass::public_key::FromPublicKey,
-};
+use ecdsa::elliptic_curve::sec1::{FromEncodedPoint, ToEncodedPoint};
+use k256_crate::ecdsa::signature::{DigestVerifier, RandomizedDigestSigner, Signature};
 use rand::rngs::OsRng;
 use rlp::DecoderError;
 use sha3::{Digest, Keccak256};
-use std::{
-    collections::BTreeMap,
-    convert::{TryFrom, TryInto},
-};
+use std::{collections::BTreeMap, convert::TryFrom};
 
 /// The ENR key that stores the public key in the ENR record.
 pub const ENR_KEY: &str = "secp256k1";
 
-type Signer = ecdsa::Signer<k256_crate::Secp256k1>;
-type Verifier = ecdsa::Verifier<k256_crate::Secp256k1>;
+type Signer = ecdsa::SigningKey<k256_crate::Secp256k1>;
+type Verifier = ecdsa::VerifyKey<k256_crate::Secp256k1>;
 
 impl EnrKey for k256_crate::SecretKey {
-    type PublicKey = k256_crate::PublicKey;
+    type PublicKey = k256_crate::EncodedPoint;
 
     fn sign_v4(&self, msg: &[u8]) -> Result<Vec<u8>, SigningError> {
         // take a keccak256 hash then sign.
         let digest = Keccak256::new().chain(msg);
-        let signature: k256_crate::ecdsa::Signature = Signer::new(self)
+        let signature: k256_crate::ecdsa::Signature = Signer::new(self.to_bytes().as_slice())
             .map_err(|_| SigningError::new("failed to create signer"))?
             .sign_digest_with_rng(&mut OsRng, digest);
 
         Ok(signature.as_bytes().to_vec())
     }
 
     fn public(&self) -> Self::PublicKey {
-        self.try_into().unwrap()
+        k256_crate::EncodedPoint::from_secret_key(self, false)
     }
 
     fn enr_to_public(content: &BTreeMap<Key, Vec<u8>>) -> Result<Self::PublicKey, DecoderError> {
@@ -43,16 +38,16 @@ impl EnrKey for k256_crate::SecretKey {
             .ok_or_else(|| DecoderError::Custom("Unknown signature"))?;
 
         // should be encoded in compressed form, i.e 33 byte raw secp256k1 public key
-        Ok(k256_crate::PublicKey::from_bytes(pubkey_bytes)
-            .ok_or_else(|| DecoderError::Custom("Invalid Secp256k1 Signature"))?)
+        Ok(k256_crate::EncodedPoint::from_bytes(pubkey_bytes)
+            .map_err(|_| DecoderError::Custom("Invalid Secp256k1 Signature"))?)
     }
 }
 
-impl EnrPublicKey for k256_crate::PublicKey {
+impl EnrPublicKey for k256_crate::EncodedPoint {
     fn verify_v4(&self, msg: &[u8], sig: &[u8]) -> bool {
         let digest = Keccak256::new().chain(msg);
         if let Ok(sig) = k256_crate::ecdsa::Signature::try_from(sig) {
-            if let Ok(verifier) = Verifier::new(self) {
+            if let Ok(verifier) = Verifier::new(self.as_bytes()) {
                 if verifier.verify_digest(digest, &sig).is_ok() {
                     return true;
                 }
@@ -63,15 +58,13 @@ impl EnrPublicKey for k256_crate::PublicKey {
 
     fn encode(&self) -> Vec<u8> {
         // serialize in compressed form: 33 bytes
-        let mut s = *self;
-        s.compress();
-        s.as_bytes().to_vec()
+        self.compress().as_bytes().to_vec()
     }
 
     fn encode_uncompressed(&self) -> Vec<u8> {
-        k256_crate::AffinePoint::from_public_key(self)
+        k256_crate::AffinePoint::from_encoded_point(self)
             .unwrap()
-            .to_pubkey(false)
+            .to_encoded_point(false)
             .as_bytes()[1..]
             .to_vec()
     }

src/lib.rs

@@ -1116,9 +1116,7 @@ mod tests {
     #[cfg(feature = "k256")]
     #[test]
     fn test_encode_decode_k256() {
-        use k256_crate::elliptic_curve::Generate;
-
-        let key = k256_crate::SecretKey::generate(&mut rand::rngs::OsRng);
+        let key = k256_crate::SecretKey::random(&mut rand::rngs::OsRng);
         let ip = Ipv4Addr::new(127, 0, 0, 1);
         let tcp = 3000;