feat: convert signing to k256

ethers-contract/ethers-contract-abigen/src/contract/methods.rs

@@ -115,7 +115,7 @@ mod tests {
         // no inputs
         let params = vec![];
         let token_stream = expand_inputs_call_arg(&params);
-        assert_eq!(token_stream.to_string(), "( )");
+        assert_eq!(token_stream.to_string(), "()");
 
         // single input
         let params = vec![Param {
@@ -137,7 +137,7 @@ mod tests {
             },
         ];
         let token_stream = expand_inputs_call_arg(&params);
-        assert_eq!(token_stream.to_string(), "( arg_a , arg_b , )");
+        assert_eq!(token_stream.to_string(), "(arg_a , arg_b ,)");
 
         // three inputs
         let params = vec![
@@ -155,7 +155,7 @@ mod tests {
             },
         ];
         let token_stream = expand_inputs_call_arg(&params);
-        assert_eq!(token_stream.to_string(), "( arg_a , arg_b , arg_c , )");
+        assert_eq!(token_stream.to_string(), "(arg_a , arg_b , arg_c ,)");
     }
 
     #[test]

ethers-core/Cargo.toml

@@ -17,10 +17,13 @@ ethabi = { package = "ethabi-next", version = "12.0.0", default-features = false
 arrayvec = { version = "0.5.1", default-features = false }
 
 # crypto
-secp256k1 = { package = "libsecp256k1", version = "0.3.5" }
+ecdsa = { version = "0.8.0", features = ["std"] }
+elliptic-curve = { version = "0.6.1", features = ["arithmetic"] }
+generic-array = "0.14.4"
+k256 = { git = "https://github.com/RustCrypto/elliptic-curves", version = "0.5.2", features = ["keccak256", "ecdsa"] }
 rand = "0.7.2"
 tiny-keccak = { version = "2.0.2", default-features = false }
-
+sha2 = { version = "0.9.1" }
 
 # misc
 serde = { version = "1.0.110", default-features = false, features = ["derive"] }

ethers-core/src/lib.rs

@@ -49,5 +49,5 @@ pub mod utils;
 // re-export rand to avoid potential confusion when there's rand version mismatches
 pub use rand;
 
-// re-export libsecp
-pub use secp256k1;
+// re-export k256
+pub use k256;

ethers-core/src/types/crypto/hash.rs

@@ -0,0 +1,85 @@
+//! This is a helper module used to pass the pre-hashed message for signing to the
+//! `sign_digest` methods of K256.
+use crate::types::H256;
+use k256::ecdsa::signature::digest::{
+    generic_array::GenericArray, BlockInput, Digest, FixedOutput, Output, Reset, Update,
+};
+
+pub type Sha256Proxy = ProxyDigest<sha2::Sha256>;
+
+#[derive(Clone)]
+pub enum ProxyDigest<D: Digest> {
+    Proxy(Output<D>),
+    Digest(D),
+}
+
+impl<D: Digest + Clone> From<H256> for ProxyDigest<D>
+where
+    GenericArray<u8, <D as Digest>::OutputSize>: Copy,
+{
+    fn from(src: H256) -> Self {
+        ProxyDigest::Proxy(*GenericArray::from_slice(src.as_bytes()))
+    }
+}
+
+impl<D: Digest> Default for ProxyDigest<D> {
+    fn default() -> Self {
+        ProxyDigest::Digest(D::new())
+    }
+}
+
+impl<D: Digest> Update for ProxyDigest<D> {
+    // we update only if we are digest
+    fn update(&mut self, data: impl AsRef<[u8]>) {
+        match self {
+            ProxyDigest::Digest(ref mut d) => {
+                d.update(data);
+            }
+            ProxyDigest::Proxy(..) => {
+                unreachable!("can not update if we are proxy");
+            }
+        }
+    }
+
+    // we chain only if we are digest
+    fn chain(self, data: impl AsRef<[u8]>) -> Self {
+        match self {
+            ProxyDigest::Digest(d) => ProxyDigest::Digest(d.chain(data)),
+            ProxyDigest::Proxy(..) => {
+                unreachable!("can not update if we are proxy");
+            }
+        }
+    }
+}
+
+impl<D: Digest> Reset for ProxyDigest<D> {
+    // make new one
+    fn reset(&mut self) {
+        *self = Self::default();
+    }
+}
+
+impl<D: Digest> BlockInput for ProxyDigest<D> {
+    type BlockSize = D::OutputSize;
+}
+
+impl<D: Digest> FixedOutput for ProxyDigest<D> {
+    // we default to the output of the orignal digest
+    type OutputSize = D::OutputSize;
+
+    fn finalize_into(self, out: &mut GenericArray<u8, Self::OutputSize>) {
+        match self {
+            ProxyDigest::Digest(d) => {
+                *out = d.finalize();
+            }
+            ProxyDigest::Proxy(p) => {
+                *out = p;
+            }
+        }
+    }
+
+    fn finalize_into_reset(&mut self, out: &mut GenericArray<u8, Self::OutputSize>) {
+        let s = core::mem::replace(self, Self::default());
+        s.finalize_into(out);
+    }
+}