Smart Contract Cairo

Mayowa.cairo

use starknet::ContractAddress;

#[starknet::interface]
trait IRoom<TContractState> {
    fn register(ref self: TContractState,) -> bool;
    fn join_room(ref self: TContractState, id: u8) -> bool;
    fn create_room(
        ref self: TContractState, title: felt252, description: felt252, members: u16
    ) -> Room::Room;
    fn get_room_details(self: @TContractState, id: u8) -> Room::Room;
    fn get_room_members(self: @TContractState, room_id: u8) -> Array<Room::Member>;
}

#[starknet::contract]
mod Room {
    use cairo_smart_contract::room::IRoom;
    use core::traits::TryInto;
    use starknet::{ContractAddress, get_caller_address};
    use core::array::ArrayTrait;

    #[storage]
    struct Storage {
        id: u8,
        registered: LegacyMap::<ContractAddress, bool>,
        rooms: LegacyMap::<u8, Room>,
        room_members: LegacyMap::<(u8, u16), Member>,
    }

    #[derive(Drop, Serde, starknet::Store)]
    struct Register {
        address: ContractAddress,
    }

    #[derive(Drop, Serde, starknet::Store)]
    struct Room {
        title: felt252,
        description: felt252,
        members: Member,
        member_count: u16,
    }

    #[derive(Drop, Serde, starknet::Store)]
    struct Member {
        id: u16,
        address: ContractAddress,
        status: bool,
    }


    #[constructor]
    fn constructor(ref self: ContractState) {
        let mut id: u8 = self.id.read();
        self.id.write(id + 1);
    }

    #[abi(embed_v0)]
    impl IRoomImpl of super::IRoom<ContractState> {
        fn register(ref self: ContractState,) -> bool {
            let caller: ContractAddress = get_caller_address();
            let register: Register = Register { address: caller };
            self.registered.write((register.address), true);
            self.registered.read(register.address)
        }

        fn join_room(ref self: ContractState, id: u8) -> bool {
            let caller: ContractAddress = get_caller_address();
            let status = self.registered.read(caller);
            assert(status == true, 'Not Registered');
            let mut room = self.rooms.read(id);
            room.member_count += 1;
            let new_member = Member { id: room.member_count, address: caller, status: true };
            room.members = new_member;
            let read_room = self.rooms.read(id);
            self.room_members.write((id, room.members.id), read_room.members);
            room.members.status
        }

        fn create_room(
            ref self: ContractState, title: felt252, description: felt252, members: u16
        ) -> Room {
            let id: u16 = 1;
            let address = get_caller_address();
            let mut new_member: Member = Member { id: id, address, status: true };

            let mut room: Room = Room {
                title, description, members: new_member, member_count: id,
            };

            self.rooms.write((self.id.read()), room);
            self.id.write(self.id.read() + 1);
            self.rooms.read(self.id.read())
        }

        fn get_room_details(self: @ContractState, id: u8) -> Room {
            self.rooms.read(id)
        }

        fn get_room_members(self: @ContractState, room_id: u8) -> Array<Member> {
            let mut members_list: Array<Member> = ArrayTrait::new();
            let mut id = self.rooms.read(room_id);
            let member_count = id.member_count;
            let mut count = 0;

            while count <= member_count {
                let list = self.get_room_member(room_id, count);
                members_list.append(list);
                count += 1
            };

            members_list
        }
    }


    #[generate_trait]
    impl Private of PrivateTrait {
        fn get_room_member(self: @ContractState, room_id: u8, member_id: u16) -> Member {
            self.room_members.read((room_id, member_id))
        }
    }
}