diff --git a/key_protocol/src/key_management/key_tree/keys_public.rs b/key_protocol/src/key_management/key_tree/keys_public.rs index fd95f666..322dd66a 100644 --- a/key_protocol/src/key_management/key_tree/keys_public.rs +++ b/key_protocol/src/key_management/key_tree/keys_public.rs @@ -6,12 +6,15 @@ use crate::key_management::key_tree::traits::KeyTreeNode; #[derive(Debug, Serialize, Deserialize, Clone)] #[cfg_attr(any(test, feature = "test_utils"), derive(PartialEq, Eq))] pub struct ChildKeysPublic { - pub cssk: nssa::PrivateKey, - pub csk: nssa::PrivateKey, - pub cpk: nssa::PublicKey, - pub ccc: [u8; 32], + /// Secret key for public account. + pub sk: nssa::PrivateKey, + /// Schnorr secret key. + pub ssk: nssa::PrivateKey, + /// Schnorr public key. + pub pk: nssa::PublicKey, + pub cc: [u8; 32], /// Can be [`None`] if root. - pub cci: Option, + pub ci: Option, } impl ChildKeysPublic { @@ -19,31 +22,31 @@ impl ChildKeysPublic { pub fn root(seed: [u8; 64]) -> Self { let hash_value = hmac_sha512::HMAC::mac(seed, "LEE_master_pub"); - let cssk = nssa::PrivateKey::try_new( + let sk = 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 csk = nssa::PrivateKey::tweak(cssk.value()).expect("`key_protocol::key_management::keys_public::root()`: Invalid private key produced from `tweak`"); + let ssk = nssa::PrivateKey::tweak(sk.value()).expect("`key_protocol::key_management::keys_public::root()`: Invalid private key produced from `tweak`"); - let ccc = *hash_value + let cc = *hash_value .last_chunk::<32>() .expect("hash_value is 64 bytes, must be safe to get last 32"); - let cpk = nssa::PublicKey::new_from_private_key(&csk); + let pk = nssa::PublicKey::new_from_private_key(&ssk); Self { - cssk, - csk, - cpk, - ccc, - cci: None, + sk, + ssk, + pk, + cc, + ci: None, } } #[must_use] - pub fn nth_child(&self, cci: u32) -> Self { - let hash_value = self.compute_hash_value(cci); + pub fn nth_child(&self, ci: u32) -> Self { + let hash_value = self.compute_hash_value(ci); let lhs = k256::Scalar::from_repr( (*hash_value @@ -52,46 +55,46 @@ impl ChildKeysPublic { .into(), ) .expect("Expect a valid k256 scalar"); - let rhs = k256::Scalar::from_repr((*self.cssk.value()).into()) + let rhs = k256::Scalar::from_repr((*self.sk.value()).into()) .expect("Expect a valid k256 scalar"); - let cssk = nssa::PrivateKey::try_new(lhs.add(&rhs).to_bytes().into()) + let sk = nssa::PrivateKey::try_new(lhs.add(&rhs).to_bytes().into()) .expect("Expect a valid private key"); - let csk = nssa::PrivateKey::tweak(cssk.value()).expect("`key_protocol::key_management::keys_public::nth_child()`: Invalid private key produced from `tweak`"); + let ssk = nssa::PrivateKey::tweak(sk.value()).expect("`key_protocol::key_management::keys_public::nth_child()`: Invalid private key produced from `tweak`"); - let ccc = *hash_value + let cc = *hash_value .last_chunk::<32>() .expect("hash_value is 64 bytes, must be safe to get last 32"); - let cpk = nssa::PublicKey::new_from_private_key(&csk); + let pk = nssa::PublicKey::new_from_private_key(&ssk); Self { - cssk, - csk, - cpk, - ccc, - cci: Some(cci), + sk, + ssk, + pk, + cc, + ci: Some(ci), } } #[must_use] pub fn account_id(&self) -> nssa::AccountId { - nssa::AccountId::from(&self.cpk) + nssa::AccountId::from(&self.pk) } - fn compute_hash_value(&self, cci: u32) -> [u8; 64] { + fn compute_hash_value(&self, ci: u32) -> [u8; 64] { let mut hash_input = vec![]; // Simplified key logic by only supporting harden keys. - // Non-harden keys would require access to untweaked public keys associated to `cssk`s. + // Non-harden keys would require access to untweaked public keys associated to `sk`s. // Thus, not PQ secure. hash_input.extend_from_slice(&[0_u8]); - hash_input.extend_from_slice(self.cssk.value()); + hash_input.extend_from_slice(self.sk.value()); #[expect(clippy::big_endian_bytes, reason = "BIP-032 uses big endian")] - hash_input.extend_from_slice(&cci.to_be_bytes()); + hash_input.extend_from_slice(&ci.to_be_bytes()); - hmac_sha512::HMAC::mac(hash_input, self.ccc) + hmac_sha512::HMAC::mac(hash_input, self.cc) } } @@ -101,7 +104,7 @@ impl ChildKeysPublic { )] impl<'a> From<&'a ChildKeysPublic> for &'a nssa::PrivateKey { fn from(value: &'a ChildKeysPublic) -> Self { - &value.csk + &value.ssk } } @@ -110,8 +113,8 @@ impl KeyTreeNode for ChildKeysPublic { Self::root(seed) } - fn derive_child(&self, cci: u32) -> Self { - self.nth_child(cci) + fn derive_child(&self, ci: u32) -> Self { + self.nth_child(ci) } fn account_ids(&self) -> impl Iterator { @@ -135,33 +138,33 @@ mod tests { ]; let keys = ChildKeysPublic::root(seed); - let expected_ccc = [ + let expected_cc = [ 238, 94, 84, 154, 56, 224, 80, 218, 133, 249, 179, 222, 9, 24, 17, 252, 120, 127, 222, 13, 146, 126, 232, 239, 113, 9, 194, 219, 190, 48, 187, 155, ]; - let expected_cssk: PrivateKey = PrivateKey::try_new([ + let expected_sk: PrivateKey = PrivateKey::try_new([ 40, 35, 239, 19, 53, 178, 250, 55, 115, 12, 34, 3, 153, 153, 72, 170, 190, 36, 172, 36, 202, 148, 181, 228, 35, 222, 58, 84, 156, 24, 146, 86, ]) .unwrap(); - let expected_csk: PrivateKey = PrivateKey::try_new([ + let expected_ssk: PrivateKey = PrivateKey::try_new([ 207, 4, 246, 223, 104, 72, 19, 85, 14, 122, 194, 82, 32, 163, 60, 57, 8, 25, 209, 91, 254, 107, 76, 238, 31, 68, 236, 192, 154, 78, 105, 118, ]) .unwrap(); - let expected_cpk: PublicKey = PublicKey::try_new([ + let expected_pk: PublicKey = PublicKey::try_new([ 188, 163, 203, 45, 151, 154, 230, 254, 123, 114, 158, 130, 19, 182, 164, 143, 150, 131, 176, 7, 27, 58, 204, 116, 5, 247, 0, 255, 111, 160, 52, 201, ]) .unwrap(); - assert!(expected_ccc == keys.ccc); - assert!(expected_cssk == keys.cssk); - assert!(expected_csk == keys.csk); - assert!(expected_cpk == keys.cpk); + assert!(expected_cc == keys.cc); + assert!(expected_ssk == keys.ssk); + assert!(expected_sk == keys.sk); + assert!(expected_pk == keys.pk); } #[test] @@ -173,35 +176,35 @@ mod tests { 187, 148, 92, 44, 253, 210, 37, ]; let root_keys = ChildKeysPublic::root(seed); - let cci = (2_u32).pow(31) + 13; - let child_keys = ChildKeysPublic::nth_child(&root_keys, cci); + let ci = (2_u32).pow(31) + 13; + let child_keys = ChildKeysPublic::nth_child(&root_keys, ci); - let expected_ccc = [ + let expected_cc = [ 149, 226, 13, 4, 194, 12, 69, 29, 9, 234, 209, 119, 98, 4, 128, 91, 37, 103, 192, 31, 130, 126, 123, 20, 90, 34, 173, 209, 101, 248, 155, 36, ]; - let expected_cssk: PrivateKey = PrivateKey::try_new([ + let expected_sk: PrivateKey = PrivateKey::try_new([ 9, 65, 33, 228, 25, 82, 219, 117, 91, 217, 11, 223, 144, 85, 246, 26, 123, 216, 107, 213, 33, 52, 188, 22, 198, 246, 71, 46, 245, 174, 16, 47, ]) .unwrap(); - let expected_csk: PrivateKey = PrivateKey::try_new([ + let expected_ssk: PrivateKey = PrivateKey::try_new([ 100, 37, 212, 81, 40, 233, 72, 156, 177, 139, 50, 114, 136, 157, 202, 132, 203, 246, 252, 242, 13, 81, 42, 100, 159, 240, 187, 252, 202, 108, 25, 105, ]) .unwrap(); - let expected_cpk: PublicKey = PublicKey::try_new([ + let expected_pk: PublicKey = PublicKey::try_new([ 210, 59, 119, 137, 21, 153, 82, 22, 195, 82, 12, 16, 80, 156, 125, 199, 19, 173, 46, 224, 213, 144, 165, 126, 70, 129, 171, 141, 77, 212, 108, 233, ]) .unwrap(); - assert!(expected_ccc == child_keys.ccc); - assert!(expected_cssk == child_keys.cssk); - assert!(expected_csk == child_keys.csk); - assert!(expected_cpk == child_keys.cpk); + assert!(expected_cc == child_keys.cc); + assert!(expected_ssk == child_keys.ssk); + assert!(expected_sk == child_keys.sk); + assert!(expected_pk == child_keys.pk); } }