Add tests for the conversions crate (#944)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #599 

## Introduced changes

Add tests for the conversions crate

- class_hash
- contract_address
- felt252
- field_element
- nonce
- short_string
- stark_felt
- stark_hash

## Breaking changes

<!-- List of all breaking changes, if applicable -->

N/A

## Checklist

<!-- Make sure all of these are complete -->

- [X] Linked relevant issue
- [ N/A] Updated relevant documentation
- [X] Added relevant tests
- [X] Performed self-review of the code
- [N/A] Added changes to `CHANGELOG.md`

---------

Co-authored-by: Marcin Warchoł <61014013+war-in@users.noreply.github.com>
Co-authored-by: Tomasz Rejowski <34059895+Arcticae@users.noreply.github.com>

Author: 3 people

crates/conversions/tests/e2e/class_hash.rs

@@ -0,0 +1,82 @@
+#[cfg(test)]
+mod tests_class_hash {
+    use conversions::StarknetConversions;
+
+    use crate::helpers::hex::str_hex_to_stark_felt;
+    use starknet_api::{core::ClassHash, hash::StarkFelt};
+
+    #[test]
+    fn test_class_hash_conversions_happy_case() {
+        let felt: StarkFelt = StarkFelt::new([1u8; 32]).unwrap();
+        let class_hash = ClassHash(felt);
+
+        assert_eq!(class_hash, class_hash.to_contract_address().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_felt252().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_field_element().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_nonce().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_short_string().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_stark_felt().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_stark_hash().to_class_hash());
+    }
+
+    #[test]
+    fn test_class_hash_conversions_zero() {
+        let felt: StarkFelt = StarkFelt::new([0u8; 32]).unwrap();
+        let class_hash = ClassHash(felt);
+
+        assert_eq!(class_hash, class_hash.to_contract_address().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_felt252().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_field_element().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_nonce().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_short_string().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_stark_felt().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_stark_hash().to_class_hash());
+    }
+
+    #[test]
+    fn test_class_hash_conversions_limit() {
+        // max_value from cairo_felt::PRIME_STR
+        let mut max_value = "0x0800000000000011000000000000000000000000000000000000000000000000";
+        let mut class_hash = ClassHash(str_hex_to_stark_felt(max_value));
+
+        assert_eq!(class_hash, class_hash.to_felt252().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_field_element().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_nonce().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_stark_felt().to_class_hash());
+        assert_eq!(class_hash, class_hash.to_stark_hash().to_class_hash());
+
+        // PATRICIA_KEY_UPPER_BOUND for contract_address from starknet_api-0.4.1/src/core.rs:156
+        max_value = "0x07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+        class_hash = ClassHash(str_hex_to_stark_felt(max_value));
+        assert_eq!(class_hash, class_hash.to_contract_address().to_class_hash());
+
+        // Unknown source for this value, founded by try and error(cairo-lang-runner-2.2.0/src/short_string.rs).
+        max_value = "0x0777777777777777777777777777777777777f7f7f7f7f7f7f7f7f7f7f7f7f7f";
+        class_hash = ClassHash(str_hex_to_stark_felt(max_value));
+
+        assert_eq!(class_hash, class_hash.to_short_string().to_class_hash());
+    }
+
+    #[test]
+    fn test_class_hash_conversions_out_of_range() {
+        // max_value from cairo_felt::PRIME_STR
+        let mut max_value = "0x0800000000000011000000000000000000000000000000000000000000000001";
+        let mut class_hash = ClassHash(str_hex_to_stark_felt(max_value));
+
+        assert_ne!(class_hash, class_hash.to_felt252().to_class_hash());
+        assert_ne!(class_hash, class_hash.to_field_element().to_class_hash());
+        assert_ne!(class_hash, class_hash.to_nonce().to_class_hash());
+        assert_ne!(class_hash, class_hash.to_stark_felt().to_class_hash());
+        assert_ne!(class_hash, class_hash.to_stark_hash().to_class_hash());
+
+        // PATRICIA_KEY_UPPER_BOUND for contract_address from starknet_api-0.4.1/src/core.rs:156
+        max_value = "0x0800000000000000000000000000000000000000000000000000000000000000";
+        class_hash = ClassHash(str_hex_to_stark_felt(max_value));
+        assert!(std::panic::catch_unwind(|| class_hash.to_contract_address()).is_err());
+
+        // Unknown source for this value, founded by try and error(cairo-lang-runner-2.2.0/src/short_string.rs).
+        max_value = "0x0777777777777777777777777777777777777f7f7f7f7f7f7f7f7f7f7f7f7f80";
+        class_hash = ClassHash(str_hex_to_stark_felt(max_value));
+        assert!(std::panic::catch_unwind(|| class_hash.to_short_string()).is_err());
+    }
+}

crates/conversions/tests/e2e/contract_address.rs

@@ -0,0 +1,135 @@
+#[cfg(test)]
+mod tests_contract_address {
+    use crate::helpers::hex::str_hex_to_stark_felt;
+    use conversions::StarknetConversions;
+    use starknet_api::{
+        core::{ContractAddress, PatriciaKey},
+        hash::StarkFelt,
+    };
+
+    #[test]
+    fn test_contract_address_conversions_happy_case() {
+        let felt: StarkFelt = StarkFelt::new([1u8; 32]).unwrap();
+        let contract_address = ContractAddress(PatriciaKey::try_from(felt).unwrap());
+
+        assert_eq!(
+            contract_address,
+            contract_address.to_class_hash().to_contract_address(),
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_felt252().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_field_element().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_nonce().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_short_string().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_stark_felt().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_stark_hash().to_contract_address()
+        );
+    }
+
+    #[test]
+    fn test_contract_address_conversions_zero() {
+        let felt: StarkFelt = StarkFelt::new([0u8; 32]).unwrap();
+        let contract_address = ContractAddress(PatriciaKey::try_from(felt).unwrap());
+
+        assert_eq!(
+            contract_address,
+            contract_address.to_class_hash().to_contract_address(),
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_felt252().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_field_element().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_nonce().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_short_string().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_stark_felt().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_stark_hash().to_contract_address()
+        );
+    }
+
+    #[test]
+    fn test_contract_address_conversions_limit() {
+        // PATRICIA_KEY_UPPER_BOUND for contract_address from starknet_api-0.4.1/src/core.rs:156
+        let mut max_value = "0x07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+        let mut contract_address =
+            ContractAddress(PatriciaKey::try_from(str_hex_to_stark_felt(max_value)).unwrap());
+
+        assert_eq!(
+            contract_address,
+            contract_address.to_class_hash().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_felt252().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_field_element().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_nonce().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_stark_felt().to_contract_address()
+        );
+        assert_eq!(
+            contract_address,
+            contract_address.to_stark_hash().to_contract_address()
+        );
+
+        // Unknown source for this value, founded by try and error(cairo-lang-runner-2.2.0/src/short_string.rs).
+        max_value = "0x0777777777777777777777777777777777777f7f7f7f7f7f7f7f7f7f7f7f7f7f";
+        contract_address =
+            ContractAddress(PatriciaKey::try_from(str_hex_to_stark_felt(max_value)).unwrap());
+
+        assert_eq!(
+            contract_address,
+            contract_address.to_short_string().to_contract_address()
+        );
+    }
+
+    #[test]
+    fn test_contract_address_conversions_out_of_range() {
+        // Can't set value bigger than max_value from PATRICIA_KEY_UPPER_BOUND
+        // so we can't test all conversions.
+
+        // Unknown source for this value, founded by try and error(cairo-lang-runner-2.2.0/src/short_string.rs).
+        let max_value = "0x0777777777777777777777777777777777777f7f7f7f7f7f7f7f7f7f7f7f7f80";
+        let contract_address =
+            ContractAddress(PatriciaKey::try_from(str_hex_to_stark_felt(max_value)).unwrap());
+
+        assert!(std::panic::catch_unwind(|| contract_address.to_short_string()).is_err());
+    }
+}

crates/conversions/tests/e2e/felt252.rs

@@ -0,0 +1,72 @@
+#[cfg(test)]
+mod tests_felt252 {
+    use crate::helpers::hex::str_hex_to_felt252;
+    use cairo_felt::Felt252;
+    use conversions::StarknetConversions;
+
+    #[test]
+    fn test_felt252_conversions_happy_case() {
+        let felt = Felt252::from(1u8);
+
+        assert_eq!(felt, felt.to_class_hash().to_felt252());
+        assert_eq!(felt, felt.to_contract_address().to_felt252());
+        assert_eq!(felt, felt.to_field_element().to_felt252());
+        assert_eq!(felt, felt.to_nonce().to_felt252());
+        assert_eq!(felt, felt.to_short_string().to_felt252());
+        assert_eq!(felt, felt.to_stark_felt().to_felt252());
+        assert_eq!(felt, felt.to_stark_hash().to_felt252());
+    }
+
+    #[test]
+    fn test_felt252_conversions_zero() {
+        let felt = Felt252::from(0u8);
+
+        assert_eq!(felt, felt.to_class_hash().to_felt252());
+        assert_eq!(felt, felt.to_contract_address().to_felt252());
+        assert_eq!(felt, felt.to_field_element().to_felt252());
+        assert_eq!(felt, felt.to_nonce().to_felt252());
+        assert_eq!(felt, felt.to_short_string().to_felt252());
+        assert_eq!(felt, felt.to_stark_felt().to_felt252());
+        assert_eq!(felt, felt.to_stark_hash().to_felt252());
+    }
+
+    #[test]
+    fn test_felt252_conversions_limit() {
+        // max_value from cairo_felt::PRIME_STR
+        let mut max_value = "0x0800000000000011000000000000000000000000000000000000000000000000";
+        let mut felt252 = str_hex_to_felt252(max_value);
+
+        assert_eq!(felt252, felt252.to_nonce().to_felt252());
+        assert_eq!(felt252, felt252.to_field_element().to_felt252());
+        assert_eq!(felt252, felt252.to_class_hash().to_felt252());
+        assert_eq!(felt252, felt252.to_stark_felt().to_felt252());
+        assert_eq!(felt252, felt252.to_stark_hash().to_felt252());
+
+        // PATRICIA_KEY_UPPER_BOUND for contract_address from starknet_api-0.4.1/src/core.rs:156
+        max_value = "0x07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+        felt252 = str_hex_to_felt252(max_value);
+        assert_eq!(felt252, felt252.to_contract_address().to_felt252());
+
+        // Unknown source for this value, founded by try and error(cairo-lang-runner-2.2.0/src/short_string.rs).
+        max_value = "0x0777777777777777777777777777777777777f7f7f7f7f7f7f7f7f7f7f7f7f7f";
+        felt252 = str_hex_to_felt252(max_value);
+
+        assert_eq!(felt252, felt252.to_short_string().to_felt252());
+    }
+
+    #[test]
+    fn test_felt252_conversions_out_of_range() {
+        // Can't set value bigger than max_value from cairo_felt::PRIME_STR
+        // so we can't test all conversions.
+
+        // PATRICIA_KEY_UPPER_BOUND for contract_address from starknet_api-0.4.1/src/core.rs:156
+        let mut max_value = "0x0800000000000000000000000000000000000000000000000000000000000000";
+        let mut felt252: Felt252 = str_hex_to_felt252(max_value);
+        assert!(std::panic::catch_unwind(|| felt252.to_contract_address()).is_err());
+
+        // Unknown source for this value, founded by try and error(cairo-lang-runner-2.2.0/src/short_string.rs).
+        max_value = "0x0777777777777777777777777777777777777f7f7f7f7f7f7f7f7f7f7f7f7f80";
+        felt252 = str_hex_to_felt252(max_value);
+        assert!(std::panic::catch_unwind(|| felt252.to_short_string()).is_err());
+    }
+}

crates/conversions/tests/e2e/field_elements.rs

@@ -0,0 +1,78 @@
+#[cfg(test)]
+mod tests_field_elements {
+    use crate::helpers::hex::str_hex_to_field_element;
+    use conversions::StarknetConversions;
+    use starknet::core::types::FieldElement;
+
+    #[test]
+    fn test_field_elements_conversions_happy_case() {
+        let field_element = FieldElement::from(1u8);
+
+        assert_eq!(
+            field_element,
+            field_element.to_class_hash().to_field_element()
+        );
+        assert_eq!(
+            field_element,
+            field_element.to_contract_address().to_field_element()
+        );
+        assert_eq!(field_element, field_element.to_felt252().to_field_element());
+        assert_eq!(field_element, field_element.to_nonce().to_field_element());
+        assert_eq!(
+            field_element,
+            field_element.to_short_string().to_field_element()
+        );
+        assert_eq!(
+            field_element,
+            field_element.to_stark_felt().to_field_element()
+        );
+        assert_eq!(
+            field_element,
+            field_element.to_stark_hash().to_field_element()
+        );
+    }
+
+    #[test]
+    fn test_field_elements_conversions_zero() {
+        let field_element = FieldElement::from(0u8);
+
+        assert_eq!(
+            field_element,
+            field_element.to_class_hash().to_field_element()
+        );
+        assert_eq!(
+            field_element,
+            field_element.to_contract_address().to_field_element()
+        );
+        assert_eq!(field_element, field_element.to_felt252().to_field_element());
+        assert_eq!(field_element, field_element.to_nonce().to_field_element());
+        assert_eq!(
+            field_element,
+            field_element.to_short_string().to_field_element()
+        );
+        assert_eq!(
+            field_element,
+            field_element.to_stark_felt().to_field_element()
+        );
+        assert_eq!(
+            field_element,
+            field_element.to_stark_hash().to_field_element()
+        );
+    }
+
+    #[test]
+    fn test_field_element_conversions_out_of_range() {
+        // Can't set value bigger than max_value from cairo_felt::PRIME_STR
+        // so we can't test all conversions.
+
+        // PATRICIA_KEY_UPPER_BOUND for contract_address from starknet_api-0.4.1/src/core.rs:156
+        let mut max_value = "0x0800000000000000000000000000000000000000000000000000000000000000";
+        let mut field_element = str_hex_to_field_element(max_value);
+        assert!(std::panic::catch_unwind(|| field_element.to_contract_address()).is_err());
+
+        // Unknown source for this value, founded by try and error(cairo-lang-runner-2.2.0/src/short_string.rs).
+        max_value = "0x0777777777777777777777777777777777777f7f7f7f7f7f7f7f7f7f7f7f7f80";
+        field_element = str_hex_to_field_element(max_value);
+        assert!(std::panic::catch_unwind(|| field_element.to_short_string()).is_err());
+    }
+}

crates/conversions/tests/e2e/mod.rs

@@ -0,0 +1,8 @@
+mod class_hash;
+mod contract_address;
+mod felt252;
+mod field_elements;
+mod nonce;
+mod short_string;
+mod stark_felt;
+mod stark_hash;