Merge branch 'main' into welcome-to-tech-palace

exercises/concept/cryptographer/.docs/instructions.md

@@ -31,15 +31,15 @@ subtract_messages(123456789, 987654321)
 
 > **Note:** The return value should be a `felt252`.
 
-## 3. Verify the Integrity of a Multiplication Operation
+## 3. Calculate a Valid Product of Two Messages
 
-To ensure the integrity of encrypted data, the cryptographic system often multiplies two field elements (`felt252`).
+To ensure the integrity of encrypted data, the cryptographic system often multiplies two messages (`felt252`) to ensure their product stays within a valid range.
 The result must be computed modulo $P$ to ensure it remains within the valid range.
 
 Implement a function that takes in two `felt252` values and returns their product, ensuring the result stays within the valid range:
 
 ```rust
-verify_multiplication(382927772233671078546147897004315551461400594453673204174697055647611, 9449570)
+multiply_messages(382927772233671078546147897004315551461400594453673204174697055647611, 9449570)
 // => 123456789
 ```
 

exercises/concept/cryptographer/.meta/config.json

@@ -1,6 +1,6 @@
 {
   "authors": [
-    "<your_gh_username>"
+    "0xNeshi"
   ],
   "files": {
     "solution": [
@@ -16,5 +16,5 @@
       "Scarb.toml"
     ]
   },
-  "blurb": "<blurb>"
+  "blurb": "Learn how to work with the Felt type by helping a cryptographer configure a secure communication system."
 }

exercises/concept/cryptographer/.meta/exemplar.cairo

@@ -0,0 +1,11 @@
+pub fn add_messages(message1: felt252, message2: felt252) -> felt252 {
+    message1 + message2
+}
+
+pub fn subtract_messages(message1: felt252, message2: felt252) -> felt252 {
+    message1 - message2
+}
+
+pub fn multiply_messages(message1: felt252, message2: felt252) -> felt252 {
+    message1 * message2
+}

exercises/concept/cryptographer/Scarb.toml

@@ -0,0 +1,7 @@
+[package]
+name = "cryptographer"
+version = "0.1.0"
+edition = "2024_07"
+
+[dev-dependencies]
+cairo_test = "2.9.2"

exercises/concept/cryptographer/src/lib.cairo

@@ -0,0 +1,11 @@
+pub fn add_messages(message1: felt252, message2: felt252) -> felt252 {
+    panic!("implement `add_messages`")
+}
+
+pub fn subtract_messages(message1: felt252, message2: felt252) -> felt252 {
+    panic!("implement `subtract_messages`")
+}
+
+pub fn multiply_messages(message1: felt252, message2: felt252) -> felt252 {
+    panic!("implement `multiply_messages`")
+}

exercises/concept/cryptographer/tests/cryptographer.cairo

@@ -0,0 +1,215 @@
+mod add_messages_tests {
+    use cryptographer::add_messages;
+
+    #[test]
+    fn positive_numbers() {
+        assert_eq!(add_messages(5, 3), 8);
+        assert_eq!(add_messages(1000, 2000), 3000);
+        assert_eq!(add_messages(1, 1), 2);
+    }
+
+    #[test]
+    #[ignore]
+    fn zero() {
+        assert_eq!(add_messages(0, 0), 0);
+        assert_eq!(add_messages(5, 0), 5);
+        assert_eq!(add_messages(0, 5), 5);
+    }
+
+    #[test]
+    #[ignore]
+    fn large_numbers() {
+        // Testing with numbers close to field limits
+        let large_num1 = 0x400000000000000000000000000000000000000000000000000000000000000;
+        let large_num2 = 0x400000000000000000000000000000000000000000000000000000000000000;
+        assert_eq!(
+            add_messages(large_num1, large_num2),
+            0x800000000000000000000000000000000000000000000000000000000000000,
+        );
+    }
+
+    #[test]
+    #[ignore]
+    fn wrapping_to_zero() {
+        let message1 = 3618502788666131213697322783095070105623107215331596699973092056135872020480;
+        let message2 = 1;
+        assert_eq!(0, add_messages(message1, message2));
+    }
+
+    #[test]
+    #[ignore]
+    fn wrapping_to_large_number() {
+        let message1 = 3618502788666131213697322783095070105623107215331596699973092056135007822949;
+        let message2 = 987654321;
+        assert_eq!(123456789, add_messages(message1, message2));
+    }
+}
+
+mod subtract_messages_tests {
+    use cryptographer::subtract_messages;
+
+    #[test]
+    #[ignore]
+    fn positive_numbers() {
+        assert_eq!(subtract_messages(5, 3), 2);
+        assert_eq!(subtract_messages(1000, 200), 800);
+        assert_eq!(subtract_messages(5, 5), 0);
+    }
+
+    #[test]
+    #[ignore]
+    fn zero() {
+        assert_eq!(subtract_messages(0, 0), 0);
+        assert_eq!(subtract_messages(5, 0), 5);
+        assert_eq!(subtract_messages(0, 5), -5);
+    }
+
+    #[test]
+    #[ignore]
+    fn large_numbers() {
+        let large_num = 0x400000000000000000000000000000000000000000000000000000000000000;
+        assert_eq!(subtract_messages(large_num, large_num), 0);
+    }
+
+    #[test]
+    #[ignore]
+    fn wrapping_to_maximum_felt252_value() {
+        let message1 = 0;
+        let message2 = 1;
+        assert_eq!(
+            3618502788666131213697322783095070105623107215331596699973092056135872020480,
+            subtract_messages(message1, message2),
+        );
+    }
+
+    #[test]
+    #[ignore]
+    fn wrapping_to_large_number() {
+        let message1 = 123456789;
+        let message2 = 987654321;
+        assert_eq!(
+            3618502788666131213697322783095070105623107215331596699973092056135007822949,
+            subtract_messages(message1, message2),
+        );
+    }
+}
+
+
+mod multiply_messages_tests {
+    use cryptographer::multiply_messages;
+
+    #[test]
+    #[ignore]
+    fn test_multiply_messages_positive_numbers() {
+        assert_eq!(multiply_messages(5, 3), 15);
+        assert_eq!(multiply_messages(10, 10), 100);
+        assert_eq!(multiply_messages(2, 4), 8);
+    }
+
+    #[test]
+    #[ignore]
+    fn test_multiply_messages_zero() {
+        assert_eq!(multiply_messages(0, 0), 0);
+        assert_eq!(multiply_messages(5, 0), 0);
+        assert_eq!(multiply_messages(0, 5), 0);
+    }
+
+    #[test]
+    #[ignore]
+    fn test_multiply_messages_one() {
+        assert_eq!(multiply_messages(1, 5), 5);
+        assert_eq!(multiply_messages(5, 1), 5);
+        assert_eq!(multiply_messages(1, 1), 1);
+    }
+
+    #[test]
+    #[ignore]
+    fn test_multiply_messages_large_numbers() {
+        let large_num1 = 0x200000000000000000000000000000000000000000000000000000000000000;
+        let large_num2 = 2;
+        assert_eq!(
+            multiply_messages(large_num1, large_num2),
+            0x400000000000000000000000000000000000000000000000000000000000000,
+        );
+    }
+
+    #[test]
+    #[ignore]
+    fn max_felt252() {
+        let message1 = 1809251394333065606848661391547535052811553607665798349986546028067936010240;
+        let message2 = 2;
+        assert_eq!(
+            3618502788666131213697322783095070105623107215331596699973092056135872020480,
+            multiply_messages(message1, message2),
+        );
+    }
+
+    #[test]
+    #[ignore]
+    fn wrapping_to_one() {
+        let message1 = 1809251394333065606848661391547535052811553607665798349986546028067936010241;
+        let message2 = 2;
+        assert_eq!(1, multiply_messages(message1, message2));
+    }
+
+    #[test]
+    #[ignore]
+    fn wrapping_to_large_number() {
+        let message1 = 382927772233671078546147897004315551461400594453673204174697055647611;
+        let message2 = 9449570;
+        assert_eq!(123456789, multiply_messages(message1, message2));
+    }
+}
+
+mod property_tests {
+    use cryptographer::{add_messages, multiply_messages};
+
+    #[test]
+    #[ignore]
+    fn test_addition_commutative() {
+        let a = 123;
+        let b = 456;
+        assert_eq!(add_messages(a, b), add_messages(b, a));
+    }
+
+    #[test]
+    #[ignore]
+    fn test_addition_associative() {
+        let a = 100;
+        let b = 200;
+        let c = 300;
+        assert_eq!(add_messages(add_messages(a, b), c), add_messages(a, add_messages(b, c)));
+    }
+
+    #[test]
+    #[ignore]
+    fn test_multiplication_commutative() {
+        let a = 123;
+        let b = 456;
+        assert_eq!(multiply_messages(a, b), multiply_messages(b, a));
+    }
+
+    #[test]
+    #[ignore]
+    fn test_multiplication_associative() {
+        let a = 2;
+        let b = 3;
+        let c = 4;
+        assert_eq!(
+            multiply_messages(multiply_messages(a, b), c),
+            multiply_messages(a, multiply_messages(b, c)),
+        );
+    }
+
+    #[test]
+    #[ignore]
+    fn test_distributive_property() {
+        let a = 2;
+        let b = 3;
+        let c = 4;
+        assert_eq!(
+            multiply_messages(a, add_messages(b, c)),
+            add_messages(multiply_messages(a, b), multiply_messages(a, c)),
+        );
+    }
+}