Cleanup

sephynox · sephynox · commit 2c643937f185 · 2026-01-28T19:20:32.000-08:00
diff --git a/keetanetwork-account/src/account.rs b/keetanetwork-account/src/account.rs
@@ -436,7 +436,7 @@ impl FromHex for IdentifierKey {
 	type Error = AccountError;
 
 	fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
-		let bytes = hex::decode(hex).map_err(|_| AccountError::InvalidConstruction)?;
+		let bytes = hex::decode(hex)?;
 		Self::try_from(bytes)
 	}
 }
@@ -1319,7 +1319,7 @@ impl FromHex for GenericAccount {
 	type Error = AccountError;
 
 	fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
-		let data = hex::decode(hex).map_err(|_| AccountError::InvalidConstruction)?;
+		let data = hex::decode(hex)?;
 		if data.is_empty() {
 			return Err(AccountError::InvalidConstruction);
 		}
@@ -2849,7 +2849,7 @@ macro_rules! impl_from_hex {
 			type Error = AccountError;
 
 			fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
-				let data = hex::decode(hex).map_err(|_| AccountError::InvalidConstruction)?;
+				let data = hex::decode(hex)?;
 				if data.len() < 2 {
 					return Err(AccountError::InvalidConstruction);
 				}
@@ -3926,6 +3926,7 @@ mod tests {
 				ed25519_account.keypair.to_public_key_string()?
 			);
 		}
+
 		Ok(())
 	}
 
@@ -4023,6 +4024,7 @@ mod tests {
 		// Test network -> token generation (should succeed)
 		let token_from_network = network_account.generate_identifier(KeyPairType::TOKEN, None, 0);
 		assert!(token_from_network.is_ok());
+
 		Ok(())
 	}
 
@@ -4524,6 +4526,7 @@ mod tests {
 		assert_eq!(network_account.to_string(), public_network.to_string());
 		assert_eq!(network_account.is_identifier(), public_network.is_identifier());
 		assert!(!public_network.has_private_key());
+
 		Ok(())
 	}
 
@@ -4582,6 +4585,7 @@ mod tests {
 				GenericAccount::Multisig(acc) => assert_eq!(acc.to_keypair_type(), KeyPairType::MULTISIG),
 			}
 		}
+
 		Ok(())
 	}
 
diff --git a/keetanetwork-account/src/error.rs b/keetanetwork-account/src/error.rs
@@ -86,6 +86,7 @@ impl From<AccountError> for KeetaNetError {
 impl_variant_error_from!(AccountError, {
 	FromHexError => InvalidConstruction,
 	keetanetwork_crypto::operations::SignatureError => InvalidConstruction,
+	core::array::TryFromSliceError => InvalidConstruction,
 });
 
 #[cfg(any(feature = "der", feature = "rasn"))]
@@ -169,6 +170,13 @@ mod tests {
 		]
 	}
 
+	// Test From conversion for TryFromSliceError
+	test_error_from_conversions! {
+		test_try_from_slice_error_conversion, AccountError, [
+			<[u8; 32]>::try_from([1u8, 2, 3].as_slice()).unwrap_err(),
+		]
+	}
+
 	#[test]
 	fn test_error_code_format() {
 		let error = AccountError::InvalidPrefix;
diff --git a/keetanetwork-asn1/src/rasn.rs b/keetanetwork-asn1/src/rasn.rs
@@ -390,11 +390,11 @@ mod tests {
 	fn test_object_identifier_ext_from_str() -> Result<(), Asn1Error> {
 		// Test valid OID strings
 		let valid_oids = [
-			("1.2.840.113549.1.1.1", vec![1, 2, 840, 113549, 1, 1, 1]), // RSA encryption
-			("1.3.101.112", vec![1, 3, 101, 112]),                      // Ed25519
-			("1.2.840.10045.3.1.7", vec![1, 2, 840, 10045, 3, 1, 7]),   // secp256r1
-			("1.3.132.0.10", vec![1, 3, 132, 0, 10]),                   // secp256k1
-			("1.2", vec![1, 2]),                                        // Simple OID
+			(oids::RSA_ENCRYPTION, vec![1, 2, 840, 113549, 1, 1, 1]),
+			(oids::ED25519, vec![1, 3, 101, 112]),
+			(oids::SECP256R1, vec![1, 2, 840, 10045, 3, 1, 7]),
+			(oids::SECP256K1, vec![1, 3, 132, 0, 10]),
+			("1.2", vec![1, 2]), // Simple OID (intentionally hardcoded)
 		];
 
 		for (oid_str, expected_arcs) in valid_oids {
@@ -425,7 +425,7 @@ mod tests {
 
 	#[test]
 	fn test_object_identifier_ext_from_str_with_as_ref() -> Result<(), Asn1Error> {
-		let oid_str = "1.3.101.112";
+		let oid_str = oids::ED25519;
 		let oid1 = ObjectIdentifier::from_str(oid_str)?;
 		let oid_string = oid_str.to_string();
 		let oid2 = ObjectIdentifier::from_str(&oid_string)?;
diff --git a/keetanetwork-asn1/src/utils.rs b/keetanetwork-asn1/src/utils.rs
@@ -403,9 +403,11 @@ mod tests {
 	use crate::error::Asn1Error;
 	use serde_json;
 
+	use crate::oids;
+
 	// Test data constants
-	const TEST_OID_STR: &str = "1.2.840.113549.1.1.1";
-	const TEST_OID_JSON: &str = r#""1.2.840.113549.1.1.1""#;
+	const TEST_OID_STR: &str = oids::RSA_ENCRYPTION;
+	const TEST_OID_JSON: &str = concat!('"', "1.2.840.113549.1.1.1", '"');
 
 	const TEST_OCTET_BYTES: &[u8] = &[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
 	const TEST_OCTET_JSON: &str = r#""0123456789abcdef""#;
@@ -414,11 +416,12 @@ mod tests {
 	const TEST_BIT_JSON: &str = r#""fedcba98""#;
 
 	// Test OID database
+	// Note: SHA256 hash OID is kept hardcoded as it's not defined in keetanetwork-asn1::oids
 	const TEST_OID_DB: &[(&str, &str)] = &[
-		("RSA", "1.2.840.113549.1.1.1"),
+		("RSA", oids::RSA_ENCRYPTION),
 		("SHA256", "2.16.840.1.101.3.4.2.1"),
-		("Ed25519", "1.3.101.112"),
-		("ECDSA_P256", "1.2.840.10045.3.1.7"),
+		("Ed25519", oids::ED25519),
+		("ECDSA_P256", oids::SECP256R1),
 	];
 
 	fn get_test_oid_db() -> HashMap<&'static str, &'static str> {
@@ -596,7 +599,7 @@ mod tests {
 
 		// Test successful lookup
 		let result = get_oid("RSA", &oid_db)?;
-		assert_eq!(result.to_string(), "1.2.840.113549.1.1.1");
+		assert_eq!(result.to_string(), oids::RSA_ENCRYPTION);
 
 		// Test unknown algorithm
 		let result = get_oid("UnknownAlgorithm", &oid_db);
@@ -616,7 +619,7 @@ mod tests {
 		let oid_db = get_test_oid_db();
 
 		// Test successful lookup
-		let result = lookup_by_oid("1.2.840.113549.1.1.1", &oid_db)?;
+		let result = lookup_by_oid(oids::RSA_ENCRYPTION, &oid_db)?;
 		assert_eq!(result, "RSA");
 
 		// Test unknown OID (using a valid but non-existent OID)
@@ -632,9 +635,9 @@ mod tests {
 
 		// Test successful lookup
 		#[cfg(feature = "der")]
-		let oid = ObjectIdentifier::new("1.2.840.113549.1.1.1")?;
+		let oid = ObjectIdentifier::new(oids::RSA_ENCRYPTION)?;
 		#[cfg(all(feature = "rasn", not(feature = "der")))]
-		let oid = crate::utils::parse_oid_string("1.2.840.113549.1.1.1")?;
+		let oid = crate::utils::parse_oid_string(oids::RSA_ENCRYPTION)?;
 
 		let result = lookup_by_object_identifier(&oid, &oid_db)?;
 		assert_eq!(result, "RSA");
@@ -654,8 +657,8 @@ mod tests {
 	#[test]
 	fn test_parse_oid_string() -> Result<(), Asn1Error> {
 		// Test successful parsing
-		let result = parse_oid_string("1.2.840.113549.1.1.1")?;
-		assert_eq!(result.to_string(), "1.2.840.113549.1.1.1");
+		let result = parse_oid_string(oids::RSA_ENCRYPTION)?;
+		assert_eq!(result.to_string(), oids::RSA_ENCRYPTION);
 
 		// Test invalid OID format
 		let result = parse_oid_string("invalid.oid");
@@ -667,7 +670,7 @@ mod tests {
 	#[test]
 	fn test_validate_oid_format() -> Result<(), Asn1Error> {
 		// Test successful validation
-		let result = validate_oid_format("1.2.840.113549.1.1.1")?;
+		let result = validate_oid_format(oids::RSA_ENCRYPTION)?;
 		assert_eq!(result, vec![1, 2, 840, 113549, 1, 1, 1]);
 
 		// Test empty string
diff --git a/keetanetwork-crypto/src/algorithms/aes_cbc.rs b/keetanetwork-crypto/src/algorithms/aes_cbc.rs
@@ -128,32 +128,30 @@ mod tests {
 
 		let result = aes_cbc.decrypt(key, short_ciphertext);
 		assert!(result.is_err());
-		assert!(matches!(result, Err(CryptoError::DecryptionFailed)));
+		assert!(matches!(result.unwrap_err(), CryptoError::DecryptionFailed));
 	}
 
 	#[test]
-	fn test_aes_256_cbc_pkcs7_padding() -> Result<(), CryptoError> {
+	fn test_aes_256_cbc_pkcs7_padding() {
 		let aes_cbc = Aes256Cbc;
 		let key = [0x42u8; 32];
 
 		// Test with data that's exactly block-aligned (16 bytes)
 		let block_aligned = [0x55u8; 16];
-		let ciphertext = aes_cbc.encrypt(key, None, block_aligned)?;
-		let decrypted = aes_cbc.decrypt(key, &ciphertext)?;
+		let ciphertext = aes_cbc.encrypt(key, None, block_aligned).unwrap();
+		let decrypted = aes_cbc.decrypt(key, &ciphertext).unwrap();
 		assert_eq!(decrypted, block_aligned);
 
 		// Test with data that needs padding (15 bytes)
 		let needs_padding = [0x66u8; 15];
-		let ciphertext = aes_cbc.encrypt(key, None, needs_padding)?;
-		let decrypted = aes_cbc.decrypt(key, &ciphertext)?;
+		let ciphertext = aes_cbc.encrypt(key, None, needs_padding).unwrap();
+		let decrypted = aes_cbc.decrypt(key, &ciphertext).unwrap();
 		assert_eq!(decrypted, needs_padding);
 
 		// Test with data that needs lots of padding (1 byte)
 		let minimal_data = [0x77u8; 1];
-		let ciphertext = aes_cbc.encrypt(key, None, minimal_data)?;
-		let decrypted = aes_cbc.decrypt(key, &ciphertext)?;
+		let ciphertext = aes_cbc.encrypt(key, None, minimal_data).unwrap();
+		let decrypted = aes_cbc.decrypt(key, &ciphertext).unwrap();
 		assert_eq!(decrypted, minimal_data);
-
-		Ok(())
 	}
 }
diff --git a/keetanetwork-crypto/src/algorithms/aes_ctr.rs b/keetanetwork-crypto/src/algorithms/aes_ctr.rs
@@ -196,44 +196,40 @@ mod tests {
 	crate::test_utils::test_aes_symmetric!(Aes128CtrCipher, 16, "AES-128-CTR");
 
 	#[test]
-	fn test_aes_128_ctr_with_iv() -> Result<(), CryptoError> {
+	fn test_aes_128_ctr_with_iv() {
 		let cipher = Aes128CtrCipher::new();
 		let key = [0x42u8; 16];
 		let iv = [0x12u8; 16];
 		let plaintext = b"Test with specific IV";
 
 		// Test encryption with specific IV
-		let ciphertext = cipher.encrypt_with_iv(key, iv, plaintext)?;
+		let ciphertext = cipher.encrypt_with_iv(key, iv, plaintext).unwrap();
 		assert_ne!(ciphertext.as_slice(), plaintext);
 		assert_eq!(ciphertext.len(), plaintext.len()); // CTR preserves length
 
 		// Test decryption with same IV
-		let decrypted = cipher.decrypt_with_iv(key, iv, &ciphertext)?;
+		let decrypted = cipher.decrypt_with_iv(key, iv, &ciphertext).unwrap();
 		assert_eq!(decrypted, plaintext);
-
-		Ok(())
 	}
 
 	#[test]
-	fn test_aes_128_ctr_deterministic_with_same_iv() -> Result<(), CryptoError> {
+	fn test_aes_128_ctr_deterministic_with_same_iv() {
 		let cipher = Aes128CtrCipher::new();
 		let key = [0x42u8; 16];
 		let iv = [0x12u8; 16];
 		let plaintext = b"Same plaintext";
 
 		// Encrypt the same plaintext with the same IV twice
 		// Should be identical (deterministic with same key + IV)
-		let ciphertext1 = cipher.encrypt_with_iv(key, iv, plaintext)?;
-		let ciphertext2 = cipher.encrypt_with_iv(key, iv, plaintext)?;
+		let ciphertext1 = cipher.encrypt_with_iv(key, iv, plaintext).unwrap();
+		let ciphertext2 = cipher.encrypt_with_iv(key, iv, plaintext).unwrap();
 		assert_eq!(ciphertext1, ciphertext2);
 
 		// Both should decrypt correctly
-		let decrypted1 = cipher.decrypt_with_iv(key, iv, &ciphertext1)?;
-		let decrypted2 = cipher.decrypt_with_iv(key, iv, &ciphertext2)?;
+		let decrypted1 = cipher.decrypt_with_iv(key, iv, &ciphertext1).unwrap();
+		let decrypted2 = cipher.decrypt_with_iv(key, iv, &ciphertext2).unwrap();
 		assert_eq!(decrypted1, plaintext);
 		assert_eq!(decrypted2, plaintext);
-
-		Ok(())
 	}
 
 	#[test]
@@ -248,41 +244,37 @@ mod tests {
 	}
 
 	#[test]
-	fn test_aes_128_ctr_default_constructor() -> Result<(), CryptoError> {
+	fn test_aes_128_ctr_default_constructor() {
 		// This fixes coverage issues and ensures the default is covered
 		#[allow(clippy::default_constructed_unit_structs)]
 		let cipher = Aes128CtrCipher::default();
 		let key = [0x42u8; 16];
 		let plaintext = b"Default constructor test";
 
-		let ciphertext = cipher.encrypt(key, None, plaintext)?;
-		let decrypted = cipher.decrypt(key, &ciphertext)?;
+		let ciphertext = cipher.encrypt(key, None, plaintext).unwrap();
+		let decrypted = cipher.decrypt(key, &ciphertext).unwrap();
 		assert_eq!(decrypted, plaintext);
-
-		Ok(())
 	}
 
 	#[test]
-	fn test_aes_128_ctr_stream_property() -> Result<(), CryptoError> {
+	fn test_aes_128_ctr_stream_property() {
 		let cipher = Aes128CtrCipher::new();
 		let key = [0x42u8; 16];
 		let iv = [0x12u8; 16];
 
 		let plaintext1 = b"short";
 		let plaintext2 = b"a much longer plaintext message";
 
-		let ciphertext1 = cipher.encrypt_with_iv(key, iv, plaintext1)?;
-		let ciphertext2 = cipher.encrypt_with_iv(key, iv, plaintext2)?;
+		let ciphertext1 = cipher.encrypt_with_iv(key, iv, plaintext1).unwrap();
+		let ciphertext2 = cipher.encrypt_with_iv(key, iv, plaintext2).unwrap();
 		assert_eq!(ciphertext1.len(), plaintext1.len());
 		assert_eq!(ciphertext2.len(), plaintext2.len());
 
 		// Verify decryption works correctly
-		let decrypted1 = cipher.decrypt_with_iv(key, iv, &ciphertext1)?;
-		let decrypted2 = cipher.decrypt_with_iv(key, iv, &ciphertext2)?;
+		let decrypted1 = cipher.decrypt_with_iv(key, iv, &ciphertext1).unwrap();
+		let decrypted2 = cipher.decrypt_with_iv(key, iv, &ciphertext2).unwrap();
 		assert_eq!(decrypted1, plaintext1);
 		assert_eq!(decrypted2, plaintext2);
-
-		Ok(())
 	}
 
 	#[test]
diff --git a/keetanetwork-crypto/src/algorithms/ed25519.rs b/keetanetwork-crypto/src/algorithms/ed25519.rs
@@ -124,10 +124,7 @@ impl TryFrom<&[u8]> for Ed25519PrivateKey {
 	type Error = CryptoError;
 
 	fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
-		let bytes_array: [u8; ed25519_dalek::SECRET_KEY_LENGTH] = bytes
-			.try_into()
-			.map_err(|_| CryptoError::InvalidPrivateKey)?;
-
+		let bytes_array: [u8; ed25519_dalek::SECRET_KEY_LENGTH] = bytes.try_into()?;
 		let signing_key = SigningKey::from_bytes(&bytes_array);
 		Ok(Ed25519PrivateKey { inner: signing_key })
 	}
@@ -262,10 +259,7 @@ impl TryFrom<&[u8]> for Ed25519PublicKey {
 	type Error = CryptoError;
 
 	fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
-		let bytes_array: [u8; ed25519_dalek::PUBLIC_KEY_LENGTH] = bytes
-			.try_into()
-			.map_err(|_| CryptoError::InvalidPublicKey)?;
-
+		let bytes_array: [u8; ed25519_dalek::PUBLIC_KEY_LENGTH] = bytes.try_into()?;
 		let verifying_key = VerifyingKey::from_bytes(&bytes_array).map_err(|_| CryptoError::InvalidPublicKey)?;
 		Ok(Ed25519PublicKey { inner: verifying_key, bytes: bytes.to_vec() })
 	}
@@ -416,10 +410,7 @@ impl TryFrom<&[u8]> for X25519PrivateKey {
 	type Error = CryptoError;
 
 	fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
-		let bytes_array: [u8; 32] = bytes
-			.try_into()
-			.map_err(|_| CryptoError::InvalidPrivateKey)?;
-
+		let bytes_array: [u8; 32] = bytes.try_into()?;
 		let bytes = bytes_array.into_secret();
 		Ok(X25519PrivateKey { bytes })
 	}
@@ -881,19 +872,19 @@ mod tests {
 		let wrong_length_bytes = [0x01; 16]; // Wrong length
 		let result = Ed25519PublicKey::try_from(wrong_length_bytes.as_slice());
 		assert!(result.is_err());
-		assert!(matches!(result, Err(CryptoError::InvalidPublicKey)));
+		assert!(matches!(result, Err(CryptoError::InvalidKeySize)));
 
 		// Test with empty bytes
 		let empty_bytes = [];
 		let result = Ed25519PublicKey::try_from(empty_bytes.as_slice());
 		assert!(result.is_err());
-		assert!(matches!(result, Err(CryptoError::InvalidPublicKey)));
+		assert!(matches!(result, Err(CryptoError::InvalidKeySize)));
 
 		// Test with too long bytes
 		let too_long_bytes = [0x01; 64]; // Too long
 		let result = Ed25519PublicKey::try_from(too_long_bytes.as_slice());
 		assert!(result.is_err());
-		assert!(matches!(result, Err(CryptoError::InvalidPublicKey)));
+		assert!(matches!(result, Err(CryptoError::InvalidKeySize)));
 	}
 
 	#[test]
diff --git a/keetanetwork-crypto/src/error.rs b/keetanetwork-crypto/src/error.rs

Original file line number	Diff line number	Diff line change
`@@ -436,7 +436,7 @@ impl FromHex for IdentifierKey {`
`436`	`436`	`type Error = AccountError;`
`437`	`437`
`438`	`438`	`fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {`
`439`		`- let bytes = hex::decode(hex).map_err(\|_\| AccountError::InvalidConstruction)?;`
	`439`	`+ let bytes = hex::decode(hex)?;`
`440`	`440`	`Self::try_from(bytes)`
`441`	`441`	`}`
`442`	`442`	`}`
`@@ -1319,7 +1319,7 @@ impl FromHex for GenericAccount {`
`1319`	`1319`	`type Error = AccountError;`
`1320`	`1320`
`1321`	`1321`	`fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {`
`1322`		`- let data = hex::decode(hex).map_err(\|_\| AccountError::InvalidConstruction)?;`
	`1322`	`+ let data = hex::decode(hex)?;`
`1323`	`1323`	`if data.is_empty() {`
`1324`	`1324`	`return Err(AccountError::InvalidConstruction);`
`1325`	`1325`	`}`
`@@ -2849,7 +2849,7 @@ macro_rules! impl_from_hex {`
`2849`	`2849`	`type Error = AccountError;`
`2850`	`2850`
`2851`	`2851`	`fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {`
`2852`		`- let data = hex::decode(hex).map_err(\|_\| AccountError::InvalidConstruction)?;`
	`2852`	`+ let data = hex::decode(hex)?;`
`2853`	`2853`	`if data.len() < 2 {`
`2854`	`2854`	`return Err(AccountError::InvalidConstruction);`
`2855`	`2855`	`}`
`@@ -3926,6 +3926,7 @@ mod tests {`
`3926`	`3926`	`ed25519_account.keypair.to_public_key_string()?`
`3927`	`3927`	`);`
`3928`	`3928`	`}`
	`3929`	`+`
`3929`	`3930`	`Ok(())`
`3930`	`3931`	`}`
`3931`	`3932`
`@@ -4023,6 +4024,7 @@ mod tests {`
`4023`	`4024`	`// Test network -> token generation (should succeed)`
`4024`	`4025`	`let token_from_network = network_account.generate_identifier(KeyPairType::TOKEN, None, 0);`
`4025`	`4026`	`assert!(token_from_network.is_ok());`
	`4027`	`+`
`4026`	`4028`	`Ok(())`
`4027`	`4029`	`}`
`4028`	`4030`
`@@ -4524,6 +4526,7 @@ mod tests {`
`4524`	`4526`	`assert_eq!(network_account.to_string(), public_network.to_string());`
`4525`	`4527`	`assert_eq!(network_account.is_identifier(), public_network.is_identifier());`
`4526`	`4528`	`assert!(!public_network.has_private_key());`
	`4529`	`+`
`4527`	`4530`	`Ok(())`
`4528`	`4531`	`}`
`4529`	`4532`
`@@ -4582,6 +4585,7 @@ mod tests {`
`4582`	`4585`	`GenericAccount::Multisig(acc) => assert_eq!(acc.to_keypair_type(), KeyPairType::MULTISIG),`
`4583`	`4586`	`}`
`4584`	`4587`	`}`
	`4588`	`+`
`4585`	`4589`	`Ok(())`
`4586`	`4590`	`}`
`4587`	`4591`