Issue 258 - remove secp256k1 for k256 (#399)

* initialize branch

* fix signatures to use k256

* fixed error

* lint fix

* lint fix

* clippy fixes

* clippy

key_protocol/Cargo.toml

@@ -8,8 +8,6 @@ license = { workspace = true }
 workspace = true
 
 [dependencies]
-secp256k1 = "0.31.1"
-
 nssa.workspace = true
 nssa_core.workspace = true
 common.workspace = true

key_protocol/src/key_management/key_tree/keys_private.rs

@@ -137,11 +137,12 @@ impl<'a> From<&'a mut ChildKeysPrivate> for &'a mut (KeyChain, nssa::Account) {
 
 #[cfg(test)]
 mod tests {
-    use nssa_core::NullifierSecretKey;
+    use nssa_core::{NullifierPublicKey, NullifierSecretKey};
 
     use super::*;
     use crate::key_management::{self, secret_holders::ViewingSecretKey};
 
+    #[expect(clippy::redundant_type_annotations, reason = "TODO: clippy requires")]
     #[test]
     fn master_key_generation() {
         let seed: [u8; 64] = [
@@ -153,7 +154,7 @@ mod tests {
 
         let keys = ChildKeysPrivate::root(seed);
 
-        let expected_ssk = key_management::secret_holders::SecretSpendingKey([
+        let expected_ssk: SecretSpendingKey = key_management::secret_holders::SecretSpendingKey([
             246, 79, 26, 124, 135, 95, 52, 51, 201, 27, 48, 194, 2, 144, 51, 219, 245, 128, 139,
             222, 42, 195, 105, 33, 115, 97, 186, 0, 97, 14, 218, 191,
         ]);
@@ -168,7 +169,7 @@ mod tests {
             34, 234, 19, 222, 2, 22, 12, 163, 252, 88, 11, 0, 163,
         ];
 
-        let expected_npk = nssa_core::NullifierPublicKey([
+        let expected_npk: NullifierPublicKey = nssa_core::NullifierPublicKey([
             7, 123, 125, 191, 233, 183, 201, 4, 20, 214, 155, 210, 45, 234, 27, 240, 194, 111, 97,
             247, 155, 113, 122, 246, 192, 0, 70, 61, 76, 71, 70, 2,
         ]);

key_protocol/src/key_management/key_tree/keys_public.rs

@@ -1,4 +1,4 @@
-use secp256k1::Scalar;
+use k256::elliptic_curve::{PrimeField as _, sec1::ToEncodedPoint as _};
 use serde::{Deserialize, Serialize};
 
 use crate::key_management::key_tree::traits::KeyNode;
@@ -13,7 +13,6 @@ pub struct ChildKeysPublic {
 }
 
 impl ChildKeysPublic {
-    #[expect(clippy::big_endian_bytes, reason = "BIP-032 uses big endian")]
     fn compute_hash_value(&self, cci: u32) -> [u8; 64] {
         let mut hash_input = vec![];
 
@@ -21,16 +20,17 @@ impl ChildKeysPublic {
             // Non-harden.
             // BIP-032 compatibility requires 1-byte header from the public_key;
             // Not stored in `self.cpk.value()`.
-            let sk = secp256k1::SecretKey::from_byte_array(*self.csk.value())
+            let sk = k256::SecretKey::from_bytes(self.csk.value().into())
                 .expect("32 bytes, within curve order");
-            let pk = secp256k1::PublicKey::from_secret_key(&secp256k1::Secp256k1::new(), &sk);
-            hash_input.extend_from_slice(&secp256k1::PublicKey::serialize(&pk));
+            let pk = sk.public_key();
+            hash_input.extend_from_slice(pk.to_encoded_point(true).as_bytes());
         } else {
             // Harden.
             hash_input.extend_from_slice(&[0_u8]);
             hash_input.extend_from_slice(self.csk.value());
         }
 
+        #[expect(clippy::big_endian_bytes, reason = "BIP-032 uses big endian")]
         hash_input.extend_from_slice(&cci.to_be_bytes());
 
         hmac_sha512::HMAC::mac(hash_input, self.ccc)
@@ -41,7 +41,12 @@ impl KeyNode for ChildKeysPublic {
     fn root(seed: [u8; 64]) -> Self {
         let hash_value = hmac_sha512::HMAC::mac(seed, "LEE_master_pub");
 
-        let csk = nssa::PrivateKey::try_new(*hash_value.first_chunk::<32>().unwrap()).unwrap();
+        let csk = nssa::PrivateKey::try_new(
+            *hash_value
+                .first_chunk::<32>()
+                .expect("hash_value is 64 bytes, must be safe to get first 32"),
+        )
+        .expect("Expect a valid Private Key");
         let ccc = *hash_value.last_chunk::<32>().unwrap();
         let cpk = nssa::PublicKey::new_from_private_key(&csk);
 
@@ -56,26 +61,20 @@ impl KeyNode for ChildKeysPublic {
     fn nth_child(&self, cci: u32) -> Self {
         let hash_value = self.compute_hash_value(cci);
 
-        let csk = secp256k1::SecretKey::from_byte_array(
-            *hash_value
-                .first_chunk::<32>()
-                .expect("hash_value is 64 bytes, must be safe to get first 32"),
-        )
-        .unwrap();
-
         let csk = nssa::PrivateKey::try_new({
-            let scalar = Scalar::from_be_bytes(*self.csk.value()).unwrap();
+            let hash_value = hash_value
+                .first_chunk::<32>()
+                .expect("hash_value is 64 bytes, must be safe to get first 32");
 
-            csk.add_tweak(&scalar)
-                .expect("Expect a valid Scalar")
-                .secret_bytes()
+            let value_1 =
+                k256::Scalar::from_repr((*hash_value).into()).expect("Expect a valid k256 scalar");
+            let value_2 = k256::Scalar::from_repr((*self.csk.value()).into())
+                .expect("Expect a valid k256 scalar");
+
+            let sum = value_1.add(&value_2);
+            sum.to_bytes().into()
         })
-        .unwrap();
-
-        assert!(
-            secp256k1::constants::CURVE_ORDER >= *csk.value(),
-            "Secret key cannot exceed curve order"
-        );
+        .expect("Expect a valid private key");
 
         let ccc = *hash_value
             .last_chunk::<32>()