implement 3% fee on purchase ticket and add checkin function

Author: dadadave80

src/event_factory/event_factory.cairo

@@ -27,7 +27,7 @@ pub mod EventFactory {
             i_ticket_721::{ITicket721Dispatcher, ITicket721DispatcherTrait},
         },
     };
-
+    pub const E18: u256 = 1000000000000000000;
     pub const STRK_TOKEN_ADDRESS: felt252 =
         0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d;
 
@@ -55,6 +55,7 @@ pub mod EventFactory {
         EventCanceled: EventCanceled,
         TicketPurchased: TicketPurchased,
         TicketRecliamed: TicketRecliamed,
+        AttendeeCheckedIn: AttendeeCheckedIn,
     }
 
     #[derive(Drop, starknet::Event)]
@@ -99,6 +100,15 @@ pub mod EventFactory {
         amount: u256
     }
 
+    #[derive(Drop, starknet::Event)]
+    struct AttendeeCheckedIn {
+        #[key]
+        event_id: u256,
+        #[key]
+        attendee: ContractAddress,
+        time: u64
+    }
+
     //*//////////////////////////////////////////////////////////////////////////
     //                                  STORAGE
     //////////////////////////////////////////////////////////////////////////*//
@@ -110,12 +120,13 @@ pub mod EventFactory {
         accesscontrol: AccessControlComponent::Storage,
         #[substorage(v0)]
         upgradeable: UpgradeableComponent::Storage,
-        event_count: u256,
-        events: Map<u256, EventData>,
-        event_ticket_balance: Map<u256, u256>,
         ticket_721_class_hash: felt252,
         tba_registry_class_hash: felt252,
         tba_accountv3_class_hash: felt252,
+        event_count: u256,
+        events: Map<u256, EventData>,
+        event_ticket_balance: Map<u256, u256>,
+        event_attendance: Map<u256, Map<ContractAddress, bool>>,
     }
 
     //*//////////////////////////////////////////////////////////////////////////
@@ -234,6 +245,13 @@ pub mod EventFactory {
             tba_address
         }
 
+        fn check_in(ref self: ContractState, event_id: u256, attendee: ContractAddress) -> bool {
+            let event_hash = self._gen_event_hash(event_id);
+            self.accesscontrol.assert_only_role(event_hash);
+            self._check_in(event_id, attendee);
+            true
+        }
+
         // -------------- GETTER FUNCTIONS -----------------------
 
         fn get_all_events(self: @ContractState) -> Array<EventData> {
@@ -481,11 +499,12 @@ pub mod EventFactory {
             let strk_token = IERC20Dispatcher {
                 contract_address: STRK_TOKEN_ADDRESS.try_into().unwrap()
             };
-            // verify if caller has enough strk token for the ticket_price
-            assert(
-                strk_token.balance_of(buyer) >= event_instance.ticket_price,
-                Errors::INSUFFICIENT_BALANCE
-            );
+
+            // verify if caller has enough strk token for the ticket_price + 3% fee
+            let _ticket_price = event_instance.ticket_price * E18;
+            let _ticket_price_ = _ticket_price + ((_ticket_price * 3) / 100);
+            let ticket_price_ = _ticket_price_ / E18;
+            assert(strk_token.balance_of(buyer) >= ticket_price_, Errors::INSUFFICIENT_BALANCE);
 
             let event_ticket_address = event_instance.ticket_addr;
             let event_ticket = ITicket721Dispatcher { contract_address: event_ticket_address };
@@ -523,6 +542,33 @@ pub mod EventFactory {
             tba_address
         }
 
+        fn _check_in(ref self: ContractState, event_id: u256, attendee: ContractAddress) {
+            let event_instance = self.events.entry(event_id).read();
+            let event_ticket_address = event_instance.ticket_addr;
+            let event_ticket = ITicket721Dispatcher { contract_address: event_ticket_address };
+
+            // assert event has started
+            assert(event_instance.start_date <= get_block_timestamp(), Errors::EVENT_NOT_STARTED);
+
+            if !event_ticket.has_event_started() {
+                event_ticket.start_event();
+            }
+
+            // assert user has a ticket
+            assert(event_ticket.balance_of(attendee) > 0, Errors::NOT_TICKET_HOLDER);
+
+            // checkin attendee
+            self.event_attendance.entry(event_id).entry(attendee).write(true);
+
+            // emit event for ticket check in
+            self
+                .emit(
+                    AttendeeCheckedIn {
+                        event_id: event_id, attendee: attendee, time: get_block_timestamp()
+                    }
+                );
+        }
+
         fn _deploy_tba(
             self: @ContractState, event_ticket_address: ContractAddress, ticket_id: u256
         ) -> ContractAddress {

src/interfaces/i_event_factory.cairo

@@ -32,6 +32,7 @@ pub trait IEventFactory<TContractState> {
     fn add_organizer(ref self: TContractState, event_id: u256, organizer: ContractAddress);
     fn remove_organizer(ref self: TContractState, event_id: u256, organizer: ContractAddress);
     fn purchase_ticket(ref self: TContractState, event_id: u256) -> ContractAddress;
+    fn check_in(ref self: TContractState, event_id: u256, attendee: ContractAddress) -> bool;
     fn get_all_events(self: @TContractState) -> Array<EventData>;
     fn get_event(self: @TContractState, event_id: u256) -> EventData;
     fn get_event_count(self: @TContractState) -> u256;