feat: implement whitelist component and contract

- Add WhitelistComponent with admin-controlled whitelist functionality
- Create WhitelistedContract that uses the whitelist component
- Add basic whitelist management functions (add/remove/check)
- Implement admin-only access control for whitelist management
- Add events for whitelist address changes
- Update project dependencies and configuration

Author: EjembiEmmanuel

.tool-versions

@@ -0,0 +1 @@
+scarb 2.11.4

Scarb.toml

@@ -6,10 +6,9 @@ edition = "2024_07"
 # See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html
 # [executable]
 [dependencies]
+starknet = "2.11.4"
 
 [cairo]
 enable-gas = false
 
 [dev-dependencies]
-cairo_test = "2.11.2"
-# cairo_execute = "2.11.3"

src/lib.cairo

@@ -1,52 +1,2 @@
-fn main() {
-    // Function calls (Uncomment to execute them)
-    // say_name("Sylvia Nnoruka!");
-    // intro_to_felt();
-    
-    let num_1 = 5;
-    let num_2 = 10;
-    let sum = sum_num(num_1, num_2);
-    println!("The sum of {} and {} is = {}", num_1, num_2, sum);
-    
-    // check_u16(6553); // Uncomment if needed
-    is_greater_than_50(3);
-}
-
-// DATA TYPES IN CAIRO
-// - felts: felt252 (Field elements)
-// - ByteArray: Represents a sequence of bytes
-// - Integers:
-//   - Signed: i8, i16, i32, i64, i128, i256
-//   - Unsigned: u8, u16, u32, u64, u128, u256
-// - Boolean: bool
-
-// Function to demonstrate ByteArray usage
-fn say_name(x: ByteArray) {
-    println!("{}", x);
-}
-
-// Function to demonstrate felt252 usage
-fn intro_to_felt() {
-    let x = 40000;
-    println!("{}", x);
-}
-
-// Function to sum two u8 integers
-fn sum_num(x: u8, y: u8) -> u8 {
-    return x + y;
-}
-
-// Function to print a u16 integer
-fn check_u16(x: u16) {
-    println!("{x}");
-}
-
-// Function to check if a u32 integer is greater than 50
-fn is_greater_than_50(x: u32) -> bool {
-    if x > 50 {
-        println!("true");
-        return true;
-    }
-    println!("false");
-    return false;
-}
+pub mod whitelist_component;
+pub mod whitelist_contract;

src/whitelist_component.cairo

@@ -0,0 +1,79 @@
+use starknet::ContractAddress;
+
+#[starknet::interface]
+pub trait IWhitelist<TContractState> {
+    fn add_to_whitelist(ref self: TContractState, address: ContractAddress);
+    fn remove_from_whitelist(ref self: TContractState, address: ContractAddress);
+    fn is_whitelisted(self: @TContractState, address: ContractAddress) -> bool;
+}
+
+#[starknet::component]
+pub mod WhitelistComponent {
+    use starknet::storage::{
+        Map, StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess,
+        StoragePointerWriteAccess,
+    };
+    use starknet::{ContractAddress, get_caller_address};
+    use super::IWhitelist;
+
+    #[storage]
+    pub struct Storage {
+        admin: ContractAddress,
+        whitelist_addresses: Map<ContractAddress, bool>,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        AddressAdded: AddressAdded,
+        AddressRemoved: AddressRemoved,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct AddressAdded {
+        address: ContractAddress,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct AddressRemoved {
+        address: ContractAddress,
+    }
+
+    #[embeddable_as(WhitelistComponent)]
+    pub impl WhitelistComponentImpl<
+        TContractState, +HasComponent<TContractState>,
+    > of IWhitelist<ComponentState<TContractState>> {
+        fn add_to_whitelist(ref self: ComponentState<TContractState>, address: ContractAddress) {
+            self.only_admin(get_caller_address());
+            self.whitelist_addresses.write(address, true);
+            self.emit(Event::AddressAdded(AddressAdded { address }));
+        }
+
+        fn remove_from_whitelist(
+            ref self: ComponentState<TContractState>, address: ContractAddress,
+        ) {
+            self.only_admin(get_caller_address());
+            self.whitelist_addresses.write(address, false);
+            self.emit(Event::AddressRemoved(AddressRemoved { address }));
+        }
+
+        fn is_whitelisted(self: @ComponentState<TContractState>, address: ContractAddress) -> bool {
+            self.whitelist_addresses.read(address)
+        }
+    }
+
+    #[generate_trait]
+    pub impl InternalImpl<
+        TContractState, +HasComponent<TContractState>,
+    > of InternalTrait<TContractState> {
+        fn initializer(ref self: ComponentState<TContractState>, admin: ContractAddress) {
+            self.admin.write(admin);
+        }
+
+        fn only_admin(self: @ComponentState<TContractState>, caller: ContractAddress) {
+            let admin: ContractAddress = self.admin.read();
+
+            assert(caller == admin, 'Caller not Admin');
+        }
+    }
+}

src/whitelist_contract.cairo

@@ -0,0 +1,38 @@
+#[starknet::contract]
+mod WhitelistedContract {
+    use starknet::get_caller_address;
+    use crate::whitelist_component::WhitelistComponent;
+
+    component!(path: WhitelistComponent, storage: whitelist, event: WhitelistEvent);
+
+    #[abi(embed_v0)]
+    impl WhitelistImpl = WhitelistComponent::WhitelistComponent<ContractState>;
+    impl InternalImpl = WhitelistComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    pub struct Storage {
+        #[substorage(v0)]
+        whitelist: WhitelistComponent::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        WhitelistEvent: WhitelistComponent::Event,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState) {
+        let deployer = get_caller_address();
+        self.whitelist.initializer(deployer);
+    }
+
+    #[external(v0)]
+    fn whitelisted_function(ref self: ContractState) -> felt252 {
+        // Only whitelisted addresses can call this function
+        let caller = get_caller_address();
+        assert(self.whitelist.is_whitelisted(caller), 'Caller is not whitelisted');
+
+        'success'
+    }
+}