Cairo test ikeh celestine chukwudi

cairo_program/Scarb.lock

@@ -2,5 +2,5 @@
 version = 1
 
 [[package]]
-name = "cairo_6"
+name = "cairo_program"
 version = "0.1.0"

cairo_program/Scarb.toml

@@ -1,11 +1,14 @@
 [package]
-name = "cairo_6"
+name = "cairo_program"
 version = "0.1.0"
 edition = "2025_12"
 
 # See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html
 
+[lib]
+
 [executable]
+name = "cairo_program"
 
 [cairo]
 enable-gas = false

cairo_program/src/integer.cairo

@@ -1,20 +1,46 @@
+use core::num::traits::{CheckedMul, CheckedAdd, CheckedSub};
+
 #[executable]
 fn main() {
-    let result: u8 = add_num(5, 6);
-    println!("the sum of x & y is: {}", result);
-    assert(result == 11, 'invalid sum logic');
+    let x: u32 = 10;
+    let y: u32 = 5;
+
+    println!("Addition: {} + {} = {}", x, y, add_num(x, y));
+    println!("Subtraction: {} - {} = {}", x, y, sub_num(x, y));
+    println!("Multiplication: {} * {} = {}", x, y, mul_num(x, y));
+    println!("Division: {} / {} = {}", x, y, div_num(x, y));
+}
+
+pub fn add_num(x: u32, y: u32) -> u32 {
+    match x.checked_add(y) {
+        Option::Some(val) => val,
+        Option::None => panic!("Addition overflow"),
+    }
+}
 
-    let sub_result: u8 = sub_num(10, 5);
-    println!("sub result is: {}", sub_result);
-    assert(sub_result == 5, 'invalid sub logic');
+pub fn sub_num(x: u32, y: u32) -> u32 {
+    if y > x {
+        panic!("Subtraction underflow");
+    }
+    match x.checked_sub(y) {
+        Option::Some(val) => val,
+        Option::None => panic!("Subtraction underflow"),
+    }
 }
 
-// addition logic
-fn add_num(x: u8, y: u8) -> u8 {
-    x + y
+pub fn mul_num(x: u32, y: u32) -> u32 {
+    match x.checked_mul(y) {
+        Option::Some(val) => val,
+        Option::None => panic!("Multiplication overflow"),
+    }
 }
 
-// subtraction logic
-fn sub_num(x: u8, y: u8) -> u8 {
-    return x - y;
+pub fn div_num(x: u32, y: u32) -> u32 {
+     if y == 0 {
+        panic!("Division by zero");
+    }
+    if y > x {
+        panic!("Result would be less than 1");
+    }
+    x / y
 }

cairo_program/src/lib.cairo

@@ -1,5 +1,5 @@
 // mod hello_world;
 // mod short_string;
-// mod integer;
+pub mod integer;
 // mod bool;
-mod bytearray;
+// mod bytearray;

starknet_contracts/Scarb.lock

@@ -1,6 +1,10 @@
 # Code generated by scarb DO NOT EDIT.
 version = 1
 
+[[package]]
+name = "cairo_program"
+version = "0.1.0"
+
 [[package]]
 name = "snforge_scarb_plugin"
 version = "0.56.0"
@@ -20,5 +24,6 @@ dependencies = [
 name = "starknet_contracts"
 version = "0.1.0"
 dependencies = [
+ "cairo_program",
  "snforge_std",
 ]

starknet_contracts/Scarb.toml

@@ -7,6 +7,7 @@ edition = "2024_07"
 
 [dependencies]
 starknet = "2.18.0"
+cairo_program = { path = "../cairo_program" }
 
 [dev-dependencies]
 snforge_std = "0.56.0"

starknet_contracts/src/lib.cairo

@@ -4,6 +4,12 @@
 pub trait ICounter<T> {
     /// Increase count.
     fn increase_count(ref self: T, amount: u32);
+    /// Decrease count.
+    fn reduce_count(ref self: T, amount: u32);
+    /// Multiply count.
+    fn multiply_count(ref self: T, amount: u32);
+    /// Divide count.
+    fn divide_count(ref self: T, amount: u32);
     /// Retrieve count.
     fn get_count(self: @T) -> u32;
 }
@@ -12,17 +18,58 @@ pub trait ICounter<T> {
 #[starknet::contract]
 mod Counter {
     use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starknet::{ContractAddress, get_caller_address};
+    use cairo_program::integer::{add_num, sub_num, mul_num, div_num};
 
     #[storage]
     struct Storage {
         count: u32,
+        owner: ContractAddress,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, owner: ContractAddress) {
+        self.owner.write(owner);
+    }
+
+    #[generate_trait]
+    impl InternalImpl of InternalTrait {
+        fn only_owner(self: @ContractState) {
+            assert(get_caller_address() == self.owner.read(), 'Caller is not the owner');
+        }
     }
 
     #[abi(embed_v0)]
     impl CounterImpl of super::ICounter<ContractState> {
         fn increase_count(ref self: ContractState, amount: u32) {
+            self.only_owner();
+            assert(amount != 0, 'Amount cannot be 0');
+            let current = self.count.read();
+            let new_count = add_num(current, amount);
+            self.count.write(new_count);
+        }
+
+        fn reduce_count(ref self: ContractState, amount: u32) {
+            self.only_owner();
+            let current = self.count.read();
+            let new_count = sub_num(current, amount);
+            self.count.write(new_count);
+        }
+
+        fn multiply_count(ref self: ContractState, amount: u32) {
+            self.only_owner();
+            assert(amount != 0, 'Amount cannot be 0');
+            let current = self.count.read();
+            let new_count = mul_num(current, amount);
+            self.count.write(new_count);
+        }
+
+        fn divide_count(ref self: ContractState, amount: u32) {
+            self.only_owner();
             assert(amount != 0, 'Amount cannot be 0');
-            self.count.write(self.count.read() + amount);
+            let current = self.count.read();
+            let new_count = div_num(current, amount);
+            self.count.write(new_count);
         }
 
         fn get_count(self: @ContractState) -> u32 {