feat:add event and basic unit test for it

.github/workflows/test_contract.yml

@@ -0,0 +1,16 @@
+name: Test
+
+on: [push, pull_request]
+permissions: read-all
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: software-mansion/setup-scarb@v1
+      - uses: foundry-rs/setup-snfoundry@v3
+        with:
+          starknet-foundry-version: 0.31.0
+      - name: Run cairo tests
+        run: snforge test

Scarb.toml

@@ -6,11 +6,11 @@ edition = "2023_11"
 # See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html
 
 [dependencies]
-starknet = "2.7.0"
+starknet = "2.8.2"
 openzeppelin = { git = "https://github.com/OpenZeppelin/cairo-contracts.git", tag = "v0.15.0" }
 
 [dev-dependencies]
-snforge_std = { git = "https://github.com/foundry-rs/starknet-foundry", tag = "v0.27.0" }
+snforge_std = { git = "https://github.com/foundry-rs/starknet-foundry", tag = "v0.31.0" }
 
 [[target.starknet-contract]]
 sierra = true

src/base/types.cairo

@@ -5,8 +5,8 @@ use core::starknet::ContractAddress;
 #[derive(Drop, Serde, starknet::Store, Clone)]
 pub struct EventDetails {
     pub event_id: u256,
-    pub name: felt252,
-    pub location: felt252,
+    pub name: ByteArray,
+    pub location: ByteArray,
     pub organizer: ContractAddress,
     pub total_register: u256,
     pub total_attendees: u256,

src/events.cairo

@@ -0,0 +1 @@
+pub mod events;

src/event/event.cairo → src/events/events.cairo

@@ -1,5 +1,5 @@
 #[starknet::contract]
-pub mod Event {
+pub mod Events {
     use core::num::traits::zero::Zero;
     use chainevents_contracts::base::types::{EventDetails, EventRegistration, EventType};
     use chainevents_contracts::base::errors::Errors::{
@@ -13,15 +13,16 @@ pub mod Event {
 
     #[storage]
     struct Storage {
-        new_events: Map<u256, EventDetails>, // map <eventId, EventDetailsParams>
-        event_counts: u256,
-        registered_events: Map<
-            u256, Map<u256, ContractAddress>
-        >, // map <eventId, RegisteredUser Address> 
-        event_attendances: Map<u256, ContractAddress>, //  map <eventId, RegisteredUser Address> 
+        // new_events: Map<u256, EventDetails>, // map <eventId, EventDetailsParams>
+        // event_counts: u256,
+        // registered_events: Map<
+        //     u256, Map<u256, ContractAddress>
+        // >, // map <eventId, RegisteredUser Address>
+        // event_attendances: Map<u256, ContractAddress>, //  map <eventId, RegisteredUser Address>
+
         // STORAGE MAPPING REFACTOR
         event_owners: Map<u256, ContractAddress>, // map(event_id, eventOwnerAddress)
-        event_count: u256,
+        event_counts: u256,
         event_details: Map<u256, EventDetails>, // map(event_id, EventDetailsParams)
         event_registrations: Map<ContractAddress, u256>, // map<attendeeAddress, event_id>
         attendee_event_details: Map<
@@ -36,16 +37,17 @@ pub mod Event {
     #[event]
     #[derive(Drop, starknet::Event)]
     enum Event {
-        NewEventRegistered: NewEventRegistered,
+        NewEventAdded: NewEventAdded,
         RegisteredForEvent: RegisteredForEvent,
         EventAttendanceMark: EventAttendanceMark
     }
 
     #[derive(Drop, starknet::Event)]
-    struct NewEventRegistered {
-        name: felt252,
-        event_id: u256,
-        location: felt252
+    pub struct NewEventAdded {
+        pub name: ByteArray,
+        pub event_id: u256,
+        pub location: ByteArray,
+        pub event_owner: ContractAddress
     }
 
     #[derive(Drop, starknet::Event)]
@@ -68,7 +70,42 @@ pub mod Event {
 
     #[abi(embed_v0)]
     impl EventsImpl of IEvent<ContractState> {
-        fn add_event(ref self: ContractState, name: ByteArray, location: ByteArray) {}
+        fn add_event(ref self: ContractState, name: ByteArray, location: ByteArray) -> u256 {
+            let event_owner = get_caller_address();
+            let event_id = self.event_counts.read() + 1;
+            let event_name = name.clone();
+            let event_location = location.clone();
+
+            let event_details = EventDetails {
+                event_id: event_id,
+                name: event_name,
+                location: event_location,
+                organizer: event_owner,
+                total_register: 0,
+                total_attendees: 0,
+                event_type: EventType::Free,
+                is_closed: false,
+                paid_amount: 0,
+            };
+
+            // save the event details
+            self.event_details.write(event_id, event_details);
+
+            // save event owner
+            self.event_owners.write(event_id, event_owner);
+
+            // emit event
+            self
+                .emit(
+                    NewEventAdded {
+                        event_id: event_id,
+                        name: name,
+                        location: location,
+                        event_owner: event_owner,
+                    }
+                );
+            event_id
+        }
         fn register_for_event(ref self: ContractState, event_id: u256, event_fee: u256) {}
         fn end_event_registration(
             ref self: ContractState, event_id: u256
@@ -78,10 +115,11 @@ pub mod Event {
 
         // GETTER FUNCTION
         fn event_details(self: @ContractState, event_id: u256) -> EventDetails {
+            let event_detail = self.event_details.read(event_id);
             let event_details = EventDetails {
                 event_id: 1,
-                name: 'demo event',
-                location: 'Dan Marna',
+                name: event_detail.name,
+                location: event_detail.location,
                 organizer: get_caller_address(),
                 total_register: 1,
                 total_attendees: 2,

src/interfaces/IEvent.cairo

@@ -3,7 +3,7 @@ use core::starknet::ContractAddress;
 #[starknet::interface]
 pub trait IEvent<TContractState> {
     // EXTERNAL FUNCTION
-    fn add_event(ref self: TContractState, name: ByteArray, location: ByteArray);
+    fn add_event(ref self: TContractState, name: ByteArray, location: ByteArray) -> u256;
     fn register_for_event(ref self: TContractState, event_id: u256, event_fee: u256);
     fn end_event_registration(
         ref self: TContractState, event_id: u256

src/lib.cairo

@@ -1,4 +1,4 @@
 pub mod base;
 pub mod interfaces;
-pub mod event;
+pub mod events;
 

tests/test_contract.cairo

@@ -1,49 +1,47 @@
-// use starknet::ContractAddress;
-
-// use snforge_std::{declare, ContractClassTrait};
-
-// use chainevents_contracts::IHelloStarknetSafeDispatcher;
-// use chainevents_contracts::IHelloStarknetSafeDispatcherTrait;
-// use chainevents_contracts::IHelloStarknetDispatcher;
-// use chainevents_contracts::IHelloStarknetDispatcherTrait;
-
-// fn deploy_contract(name: ByteArray) -> ContractAddress {
-//     let contract = declare(name).unwrap();
-//     let (contract_address, _) = contract.deploy(@ArrayTrait::new()).unwrap();
-//     contract_address
-// }
-
-// #[test]
-// fn test_increase_balance() {
-//     let contract_address = deploy_contract("HelloStarknet");
-
-//     let dispatcher = IHelloStarknetDispatcher { contract_address };
-
-//     let balance_before = dispatcher.get_balance();
-//     assert(balance_before == 0, 'Invalid balance');
-
-//     dispatcher.increase_balance(42);
-
-//     let balance_after = dispatcher.get_balance();
-//     assert(balance_after == 42, 'Invalid balance');
-// }
-
-// #[test]
-// #[feature("safe_dispatcher")]
-// fn test_cannot_increase_balance_with_zero_value() {
-//     let contract_address = deploy_contract("HelloStarknet");
-
-//     let safe_dispatcher = IHelloStarknetSafeDispatcher { contract_address };
-
-//     let balance_before = safe_dispatcher.get_balance().unwrap();
-//     assert(balance_before == 0, 'Invalid balance');
-
-//     match safe_dispatcher.increase_balance(0) {
-//         Result::Ok(_) => core::panic_with_felt252('Should have panicked'),
-//         Result::Err(panic_data) => {
-//             assert(*panic_data.at(0) == 'Amount cannot be 0', *panic_data.at(0));
-//         }
-//     };
-// }
-
+// *************************************************************************
+//                              Events TEST
+// *************************************************************************
+use core::option::OptionTrait;
+use core::starknet::SyscallResultTrait;
+use core::result::ResultTrait;
+use core::traits::{TryInto, Into};
+use starknet::{ContractAddress};
+
+use snforge_std::{
+    declare, start_cheat_caller_address, stop_cheat_caller_address, ContractClassTrait,
+    DeclareResultTrait,
+};
+
+use chainevents_contracts::interfaces::IEvent::{IEventDispatcher, IEventDispatcherTrait};
+
+
+const USER_ONE: felt252 = 'JOE';
+const USER_TWO: felt252 = 'DOE';
+
+// *************************************************************************
+//                              SETUP
+// *************************************************************************
+fn __setup__() -> ContractAddress {
+    // deploy  events
+    let events_class_hash = declare("Events").unwrap().contract_class();
+
+    let mut events_constructor_calldata: Array<felt252> = array![];
+    let (event_contract_address, _) = events_class_hash
+        .deploy(@events_constructor_calldata)
+        .unwrap();
+
+    return (event_contract_address);
+}
+
+#[test]
+fn test_add_event() {
+    let event_contract_address = __setup__();
+
+    let event_dispatcher = IEventDispatcher { contract_address: event_contract_address };
+
+    start_cheat_caller_address(event_contract_address, USER_ONE.try_into().unwrap());
+    let event_id = event_dispatcher.add_event("bitcoin dev meetup", "Dan Marna road");
+    assert(event_id == 1, 'Event was not created');
+    stop_cheat_caller_address(event_contract_address);
+}