Merge branch 'main' into add_learning_materials

Author: diegokingston

benches/Cargo.toml

@@ -9,9 +9,9 @@ ark-test-curves = { git = "https://github.com/arkworks-rs/algebra", rev = "ef8f7
 ark-std = "0.4.0"
 rand = "0.8.5"
 rand_chacha = "0.3.1"
-starknet-curve = { git = "https://github.com/xJonathanLEI/starknet-rs" }
-starknet-ff = { git = "https://github.com/xJonathanLEI/starknet-rs" }
-starknet-crypto = { git = "https://github.com/xJonathanLEI/starknet-rs" }
+starknet-curve = { git = "https://github.com/xJonathanLEI/starknet-rs", tag = "starknet-curve/v0.4.2" }
+starknet-ff = { git = "https://github.com/xJonathanLEI/starknet-rs", tag = "starknet-ff/v0.3.7" }
+starknet-crypto = { git = "https://github.com/xJonathanLEI/starknet-rs", tag = "starknet-crypto/v0.6.2" }
 pathfinder-crypto = { git = "https://github.com/eqlabs/pathfinder.git" }
 
 [dependencies.lambdaworks-math]

benches/benches/poseidon.rs

@@ -31,8 +31,8 @@ fn poseidon_benchmarks(c: &mut Criterion) {
     mont_x.reverse();
     mont_y.reverse();
 
-    let sn_ff_x = starknet_ff::FieldElement::from_mont(mont_x);
-    let sn_ff_y = starknet_ff::FieldElement::from_mont(mont_y);
+    let sn_ff_x = starknet_crypto::FieldElement::from_mont(mont_x);
+    let sn_ff_y = starknet_crypto::FieldElement::from_mont(mont_y);
     group.bench_function("starknet-rs", |bench| {
         bench.iter(|| black_box(starknet_crypto::poseidon_hash(sn_ff_x, sn_ff_y)))
     });

crypto/src/merkle_tree/merkle.rs

@@ -33,11 +33,6 @@ where
     pub fn build(unhashed_leaves: &[B::Data]) -> Self {
         let mut hashed_leaves: Vec<B::Node> = B::hash_leaves(unhashed_leaves);
 
-        // If there is only one node, handle it specially
-        if hashed_leaves.len() == 1 {
-            hashed_leaves.push(hashed_leaves[0].clone());
-        }
-
         //The leaf must be a power of 2 set
         hashed_leaves = complete_until_power_of_two(&mut hashed_leaves);
         let leaves_len = hashed_leaves.len();

crypto/src/merkle_tree/utils.rs

@@ -22,17 +22,20 @@ pub fn parent_index(node_index: usize) -> usize {
 
 // The list of values is completed repeating the last value to a power of two length
 pub fn complete_until_power_of_two<T: Clone>(values: &mut Vec<T>) -> Vec<T> {
-    if values.len() == 1 {
-        return values.clone(); // Return immediately if there is only one element.
-    }
     while !is_power_of_two(values.len()) {
         values.push(values[values.len() - 1].clone());
     }
     values.to_vec()
 }
 
-pub fn is_power_of_two(x: usize) -> bool {
-    (x != 0) && ((x & (x - 1)) == 0)
+// ! NOTE !
+// We in this function we  say 2^0 = 1 is not a power of two when it is infact true. We
+// need this to maintain that the smallest tree at two leaves counts and we could not find
+// a name that wasn't overly verbose. In the case of a single value being present in a leaf node
+// this indicates we pad to next power of two (i.e. 2). The function is private and is only used
+// to ensure the tree has a power of 2 number of leaves.
+fn is_power_of_two(x: usize) -> bool {
+    (x > 1) && ((x & (x - 1)) == 0)
 }
 
 // ! CAUTION !
@@ -109,6 +112,19 @@ mod tests {
         }
     }
 
+    #[test]
+    // expected |2|2|
+    fn complete_the_length_of_one_field_element_to_be_a_power_of_two() {
+        let mut values: Vec<FE> = vec![FE::new(2)];
+        let hashed_leaves = complete_until_power_of_two(&mut values);
+
+        let mut expected_leaves = vec![FE::new(2)];
+        expected_leaves.extend([FE::new(2)]);
+        assert_eq!(hashed_leaves.len(), 2);
+        assert_eq!(hashed_leaves[0], expected_leaves[0]);
+        assert_eq!(hashed_leaves[1], expected_leaves[1]);
+    }
+
     const ROOT: usize = 0;
 
     #[test]

math/src/errors.rs

@@ -11,6 +11,7 @@ pub enum ByteConversionError {
 pub enum CreationError {
     InvalidHexString,
     InvalidDecString,
+    HexStringIsTooBig,
     EmptyString,
 }
 

math/src/field/element.rs

@@ -509,14 +509,14 @@ impl<F: IsPrimeField> FieldElement<F> {
     /// Creates a `FieldElement` from a hexstring. It can contain `0x` or not.
     /// Returns an `CreationError::InvalidHexString`if the value is not a hexstring.
     /// Returns a `CreationError::EmptyString` if the input string is empty.
+    /// Returns a `CreationError::HexStringIsTooBig` if the the input hex string is bigger
+    /// than the maximum amount of characters for this element.
     pub fn from_hex(hex_string: &str) -> Result<Self, CreationError> {
         if hex_string.is_empty() {
-            return Err(CreationError::EmptyString)?;
+            return Err(CreationError::EmptyString);
         }
-
-        Ok(Self {
-            value: F::from_hex(hex_string)?,
-        })
+        let value = F::from_hex(hex_string)?;
+        Ok(Self { value })
     }
 
     #[cfg(feature = "std")]

math/src/field/fields/montgomery_backed_prime_fields.rs

@@ -1149,6 +1149,22 @@ mod tests_u256_prime_fields {
         assert_eq!(a, b);
     }
 
+    #[test]
+    fn creating_a_field_element_from_hex_too_big_errors() {
+        let a = U256FP1Element::from_hex(&"f".repeat(65));
+        assert!(a.is_err());
+        assert_eq!(
+            a.unwrap_err(),
+            crate::errors::CreationError::HexStringIsTooBig
+        )
+    }
+
+    #[test]
+    fn creating_a_field_element_from_hex_works_on_the_size_limit() {
+        let a = U256FP1Element::from_hex(&"f".repeat(64));
+        assert!(a.is_ok());
+    }
+
     #[test]
     fn creating_a_field_element_from_hex_works_2() {
         let a = U256F29Element::from_hex_unchecked("aa");

math/src/unsigned_integer/element.rs

@@ -425,6 +425,8 @@ impl<const NUM_LIMBS: usize> UnsignedInteger<NUM_LIMBS> {
     /// Creates an `UnsignedInteger` from a hexstring. It can contain `0x` or not.
     /// Returns an `CreationError::InvalidHexString`if the value is not a hexstring.
     /// Returns a `CreationError::EmptyString` if the input string is empty.
+    /// Returns a `CreationError::HexStringIsTooBig` if the the input hex string is bigger
+    /// than the maximum amount of characters for this element.
     pub fn from_hex(value: &str) -> Result<Self, CreationError> {
         let mut string = value;
         let mut char_iterator = value.chars();
@@ -440,6 +442,14 @@ impl<const NUM_LIMBS: usize> UnsignedInteger<NUM_LIMBS> {
         if !Self::is_hex_string(string) {
             return Err(CreationError::InvalidHexString);
         }
+
+        // Limbs are of 64 bits - 8 bytes
+        // We have 16 nibbles per bytes
+        let max_amount_of_hex_chars = NUM_LIMBS * 16;
+        if string.len() > max_amount_of_hex_chars {
+            return Err(CreationError::HexStringIsTooBig);
+        }
+
         Ok(Self::from_hex_unchecked(string))
     }
 
@@ -1001,7 +1011,7 @@ impl<const NUM_LIMBS: usize> Arbitrary for UnsignedInteger<NUM_LIMBS> {
 #[cfg(test)]
 mod tests_u384 {
     use crate::traits::ByteConversion;
-    use crate::unsigned_integer::element::{UnsignedInteger, U384};
+    use crate::unsigned_integer::element::{UnsignedInteger, U256, U384};
     #[cfg(feature = "proptest")]
     use proptest::prelude::*;
     #[cfg(feature = "proptest")]
@@ -1246,6 +1256,21 @@ mod tests_u384 {
         );
     }
 
+    #[test]
+    fn from_hex_with_overflowing_hexstring_should_error() {
+        let u256_from_big_string = U256::from_hex(&"f".repeat(65));
+        assert!(u256_from_big_string.is_err());
+        assert!(
+            u256_from_big_string
+                == Err(crate::unsigned_integer::element::CreationError::HexStringIsTooBig)
+        );
+    }
+
+    #[test]
+    fn from_hex_with_non_overflowing_hexstring_should_work() {
+        assert_eq!(U256::from_hex(&"0".repeat(64)).unwrap().limbs, [0, 0, 0, 0])
+    }
+
     #[test]
     fn construct_new_integer_from_dec_1() {
         let a = U384::from_dec_str("1").unwrap();