Welcome to Cairo Academy: Jumpstart Your Starknet Development

Leverage Predefined Templates to Build on Starknet Faster

Cairo Academy simplifies your journey into Starknet development by providing a collection of ready-to-use templates. These templates are designed to accelerate your learning and development process, allowing you to focus on building innovative decentralized applications.

Why Templates?

• Rapid Prototyping: Skip the initial setup and dive straight into building your application.
• Best Practices: Learn from well-structured code and established design patterns.
• Reduced Learning Curve: Get a head start by utilizing pre-built components and functionalities.
• Consistency: Maintain code quality and uniformity across your projects.
• Community Contributions: Benefit from templates created and improved by the Starknet community.

What You'll Find

Cairo Academy offers a variety of templates catering to different use cases:

• Basic Smart Contract Template: A foundational template for deploying simple smart contracts on Starknet.
• Token Contract Template: A template for creating fungible or non-fungible tokens.
• DAO Template: A starting point for building decentralized autonomous organizations.
• Game Template: A template for developing on-chain games with Cairo.
• DeFi Template: A template for building decentralized finance applications.
• And more: We are constantly expanding our template library to cover a wide range of applications.

How to Use the Templates

1. Browse Templates: Explore the available templates and choose one that fits your project requirements.
2. Customize: Modify the template code to fit your specific application logic.
3. Deploy: Compile and deploy your customized smart contract on Starknet.
4. Iterate: Build upon the template and add new features.

Cairo Academy: Architecture and Vision

Welcome to the Cairo Academy Architecture documentation!

This document outlines the vision, mission, and scope of Cairo Academy, a platform dedicated to simplifying and accelerating StarkNet dApp development. Our goal is to empower developers to create and deploy fully functional decentralized applications (dApps) on StarkNet rapidly.

Vision

To be the definitive resource for StarkNet development, enabling rapid dApp creation and deployment, and fostering a vibrant ecosystem of Cairo developers.

Mission

To provide comprehensive educational resources, streamlined development tools, and intuitive templates that empower developers to build and deploy innovative dApps on StarkNet quickly and efficiently.

Scope

Cairo Academy encompasses the following key areas:

1. Educational Resources:
   • Interactive learning modules and practical examples.
   • A dedicated Cairo Academy platform for structured learning.
2. Development Tools and Templates:
   • A gaming repository (Dojo and Cartridge game templates) to facilitate game development on StarkNet.
   • An AI Agent repository to facilitate AI Agent projects on StarkNet.
   • Pre-built, customizable dApp templates for various use cases.
   • Tools for rapid dApp scaffolding and deployment.
   • A library of useful Cairo contracts.
3. Deployment Automation:
   • One-click deployment solutions for StarkNet testnet and mainnet.
   • Continuous integration and continuous deployment (CI/CD) pipelines.
   • Streamlined deployment workflows that minimize manual effort.
4. Community Building:
   • A vibrant community forum for developers to connect, collaborate, and share knowledge.
   • Regular workshops, webinars, and hackathons.
   • Mentorship programs to support aspiring Cairo developers.
5. Architecture Overview:
   • Modular Design: Cairo Academy is designed with a modular architecture, allowing for easy expansion and integration of new features and tools.
   • Template-Driven Development: We emphasize the use of templates to accelerate dApp creation.
   • Automated Deployment: We prioritize automated deployment workflows to minimize friction and speed up time-to-market.
   • Community-Centric: We foster a strong community to support developers and drive innovation.
6. End Goal: Rapid dApp Deployment:
   • Our ultimate goal is to enable developers to create, configure, and deploy fully functional dApps on StarkNet rapidly.
   • This will be achieved through the combination of intuitive templates, automated deployment tools, and comprehensive documentation.

Repository Contents

• vision_mission_scope.md: This document.
• diagrams/: Architectural diagrams and flowcharts.
• documentation/: Detailed documentation on the Cairo Academy architecture.
• roadmap.md: The planned development roadmap for Cairo Academy.
• mdbook: Website

Introduction to Cairo Academy's Sample Smart Contracts

Welcome to the Cairo Academy's collection of sample Cairo smart contracts, designed for educational purposes. This resource aims to provide developers with accessible examples to learn Cairo and build on StarkNet.

Purpose

This chapter introduces the Cairo Academy's sample smart contracts, outlining their purpose, structure, and intended use. These contracts serve as practical examples for developers learning Cairo and exploring the StarkNet ecosystem.

Cairo Academy: An Educational Resource

Cairo Academy is dedicated to providing high-quality educational resources for developers interested in learning Cairo and building on StarkNet. We curate and share sample smart contracts, tutorials, and other learning materials to facilitate the mastery of Cairo and encourage contributions to the StarkNet ecosystem.

Important Note: Cairo Academy focuses exclusively on educational resources. The provided contracts are not intended for production use.

Cairo Academy: Understanding a Basic ERC20 Token Contract

This chapter delves into a fundamental ERC20 token contract implemented in Cairo. This contract demonstrates the core functionalities of a standard ERC20 token, providing a practical example for learning how to build fungible tokens on StarkNet.

Purpose and Functionality

The provided Cairo code defines a basic ERC20 token contract. It implements essential functionalities such as:

• Token Minting: Creating new tokens and assigning them to an address.
• Token Transfer: Moving tokens between different addresses.
• Allowance and Approval: Allowing one address to transfer tokens on behalf of another.
• Balance and Supply Tracking: Maintaining records of user balances and the total token supply.
• Metadata: Providing basic token information like name, symbol, and decimals.
• Withdrawal: Allowing the contract owner to withdraw tokens from the contract.

This contract serves as a foundational example for understanding the mechanics of ERC20 tokens within the StarkNet ecosystem.

#![allow(unused)]
fn main() {
use starknet::ContractAddress;
use starknet::storage::Map;
use starknet::{get_caller_address, get_contract_address};

#[starknet::interface]
trait IToken<TContractState> {
    fn mint(ref self: TContractState, address: ContractAddress);
    fn transfer(ref self: TContractState, address: ContractAddress, amount: u128);
    fn approval(ref self: TContractState, from: ContractAddress, to: ContractAddress, amount: u128);
    fn allowance(self: @TContractState, from: ContractAddress, to: ContractAddress) -> u128;
    fn transfer_from(ref self: TContractState, from: ContractAddress, to: ContractAddress, amount: u128);
    fn withdrawTokens(ref self: TContractState, contract_address: ContractAddress, amount: u128);
    fn get_name(self: @TContractState) -> felt252;
    fn get_symbol(self: @TContractState) -> felt252;
    fn get_decimal(self: @ContractState) -> u128;
    fn get_total_supply(self: @ContractState) -> u128;
    fn get_balance_of_user(self: @TContractState, user: ContractAddress) -> u128;
    fn get_owner(self: @ContractState) -> ContractAddress;
}

#[starknet::contract]
mod ERC20Token {
    use super::IToken;
    use starknet::{ContractAddress, get_caller_address, get_contract_address};
    use starknet::storage::Map;

    #[storage]
    struct Storage {
        name: felt252,
        symbol: felt252,
        decimal: u128,
        total_supply: u128,
        owner: ContractAddress,
        balance_of: Map::<ContractAddress, u128>,
        allowance: Map::<(ContractAddress, ContractAddress), u128>,
    }

    #[constructor]
    fn constructor(ref self: ContractState) {
        self.name.write('ERC20Token');
        self.symbol.write('ETK');
        self.decimal.write(18);
        self.owner.write(get_caller_address());
    }

    #[event]
    #[derive(Drop, starknet::Event)]
    enum Event {
        TransferFrom: TransferFrom,
        Transfer: Transfer,
        Mint: Mint,
        Withdraw: Withdraw,
        Approval: Approval,
    }

    #[derive(Drop, starknet::Event)]
    struct TransferFrom {
        #[key]
        from: ContractAddress,
        to: ContractAddress,
        amount: u128,
    }

    #[derive(Drop, starknet::Event)]
    struct Transfer {
        #[key]
        to: ContractAddress,
        amount: u128,
    }

    #[derive(Drop, starknet::Event)]
    struct Mint {
        #[key]
        to: ContractAddress,
        amount: u128,
    }

    #[derive(Drop, starknet::Event)]
    struct Withdraw {
        #[key]
        contract_address: ContractAddress,
        user: ContractAddress,
        amount: u128,
    }

    #[derive(Drop, starknet::Event)]
    struct Approval {
        #[key]
        user: ContractAddress,
        to: ContractAddress,
        amount: u128,
    }

    #[abi(embed_v0)]
    impl ITokenImpl of super::IToken<ContractState> {
        fn mint(ref self: ContractState, address: ContractAddress) {
            let caller: ContractAddress = get_caller_address();
            assert(!caller.is_zero(), 'Caller cannot be address zero');
            let supply: u128 = self.total_supply.read();
            let balance: u128 = self.balance_of.read(get_caller_address());
            self.total_supply.write(supply + 1000);
            self.balance_of.write(get_caller_address(), balance + 1000);
            self.emit(Mint { to: get_caller_address(), amount: 1000 });
        }
        fn transfer(ref self: ContractState, address: ContractAddress, amount: u128) {
            let sender_balance: u128 = self.balance_of.read(get_caller_address());
            let reciever_balance: u128 = self.balance_of.read(address);
            assert(sender_balance >= amount, 'Not Enough Tokens');
            self.balance_of.write(get_caller_address(), sender_balance - amount);
            self.balance_of.write(address, reciever_balance + amount);
            self.emit(Transfer { to: address, amount: amount });
        }
        fn approval(ref self: ContractState, from: ContractAddress, to: ContractAddress, amount: u128) {
            self.allowance.write((from, to), self.allowance.read((from, to)) + amount);
            self.emit(Approval { user: from, to: to, amount: amount });
        }
        fn allowance(self: @ContractState, from: ContractAddress, to: ContractAddress) -> u128 {
            self.allowance.read((from, to))
        }
        fn transfer_from(ref self: ContractState, from: ContractAddress, to: ContractAddress, amount: u128) {
            assert(self.allowance.read((from, to)) >= amount, 'Insufficient Allowance');
            self.allowance.write((from, to), self.allowance.read((from, to)) - amount);
            assert(self.balance_of.read(from) >= amount, 'Not Enough Tokens');
            self.balance_of.write(from, self.balance_of.read(from) - amount);
            self.balance_of.write(to, self.balance_of.read(to) + amount);
            self.emit(TransferFrom { from: from, to: to, amount: amount });
        }
        fn withdrawTokens(ref self: ContractState, contract_address: ContractAddress, amount: u128) {
            let contract_balance = self.balance_of.read(get_contract_address());
            let caller_balance = self.balance_of.read(get_caller_address());
            assert(contract_balance >= amount, 'Contract balance Insufficient');
            self.balance_of.write(get_caller_address(), caller_balance + amount);
            self.balance_of.write(get_contract_address(), contract_balance - amount);
            self.emit(Withdraw { contract_address: contract_address, user: get_caller_address(), amount });
        }
        fn get_name(self: @ContractState) -> felt252 {
            self.name.read()
        }
        fn get_symbol(self: @ContractState) -> felt252 {
            self.symbol.read()
        }
        fn get_decimal(self: @ContractState) -> u128 {
            self.decimal.read()
        }
        fn get_total_supply(self: @ContractState) -> u128 {
            self.total_supply.read()
        }
        fn get_balance_of_user(self: @ContractState, user: ContractAddress) -> u128 {
            self.balance_of.read(user)
        }
        fn get_owner(self: @ContractState) -> ContractAddress {
            self.owner.read()
        }
}

Cairo Academy: Understanding a Basic Lottery Contract

This chapter delves into the basics of a lottery contract implemented in Cairo. This contract demonstrates the core functionalities of a basic lottery contract, providing a practical example for learning how to build a basic lottery contract on StarkNet.

Purpose and Functionality

The provided Cairo code defines a basic lottery contract. It implements essential functionalities such as:

• Start Lottery: This starts the operation of a lottery round. This takes in parameters: ticket_price : Price of a single lottery ticket in wei max_tickets : Maximum number of tickets for this lottery round prize_distribution : Array containing percentage distribution of prizes (must sum to 100) duration : Duration of the lottery in seconds

• Buy lottery tickets: Buy lottery tickets. This takes parameters: ticket_count : Number of tickets to purchase

• End the lottery and select winners:. This takes parametrs: random_seed : Additional entropy source to enhance randomness

• Claim prizes for the caller if they won

We have some view functions. These are functions that read data from the blockcahin.

• Get lottery information : This get the lottery information
• Get ticket holder : This gets the information about the lottery ticket holder
• Get Winner : This gets the winner information
• Get user tickets : This gets information about the user tickets
• Is the lottery active This return a bool (true or flase) the active state of the lottery ticket

This contract serves as a foundational example for understanding the mechanics of Lottery Contract within the StarkNet ecosystem.

#![allow(unused)]
fn main() {
use starknet::ContractAddress;
use array::ArrayTrait;
use option::OptionTrait;

#[starknet::interface]
pub trait ILotteryContract<TContractState> {
    fn start_lottery(
        ref self: TContractState,
        ticket_price: u256,
        max_tickets: u32,
        prize_distribution: Array<u8>,
        duration: u64
    );
    fn buy_tickets(ref self: TContractState, ticket_count: u32);
    fn end_lottery(ref self: TContractState, random_seed: felt252);
    fn claim_prize(ref self: TContractState);
    fn get_lottery_info(self: @TContractState) -> LotteryInfo;
    fn get_ticket_holders(self: @TContractState) -> Array<ContractAddress>;
    fn get_winners(self: @TContractState) -> Array<Winner>;
    fn get_user_tickets(self: @TContractState, user: ContractAddress) -> u32;
    fn is_lottery_active(self: @TContractState) -> bool;
}

#[derive(Copy, Drop, Serde, starknet::Store)]
pub struct LotteryInfo {
    lottery_id: u32,
    ticket_price: u256,
    max_tickets: u32,
    tickets_sold: u32,
    prize_pool: u256,
    start_time: u64,
    end_time: u64,
    lottery_status: u8, 
}

#[derive(Copy, Drop, Serde)]
pub struct Winner {
    address: ContractAddress,
    prize_amount: u256,
    claimed: bool
}

mod Errors {
    pub const LOTTERY_ALREADY_ACTIVE: felt252 = 'Lottery already active';
    pub const INVALID_TICKET_PRICE: felt252 = 'Invalid ticket price';
    pub const INVALID_MAX_TICKETS: felt252 = 'Invalid max tickets';
    pub const INVALID_DURATION: felt252 = 'Invalid duration';
    pub const INVALID_DISTRIBUTION: felt252 = 'Invalid prize distribution';
    pub const LOTTERY_NOT_ACTIVE: felt252 = 'Lottery not active';
    pub const LOTTERY_NOT_ENDED: felt252 = 'Lottery still active';
    pub const LOTTERY_ALREADY_ENDED: felt252 = 'Lottery already ended';
    pub const MAX_TICKETS_REACHED: felt252 = 'Max tickets reached';
    pub const INSUFFICIENT_PAYMENT: felt252 = 'Insufficient payment';
    pub const NOT_OWNER: felt252 = 'Not the contract owner';
    pub const NO_PRIZES_TO_CLAIM: felt252 = 'No prizes to claim';
    pub const PRIZE_ALREADY_CLAIMED: felt252 = 'Prize already claimed';
}

#[starknet::contract]
pub mod LotteryContract {
    use super::{
        ILotteryContract, LotteryInfo, Winner, Errors,
        ArrayTrait, ContractAddress, OptionTrait
    };
    use core::num::traits::Zero;
    use starknet::{
        get_caller_address, get_block_timestamp, get_block_number, get_tx_info,
        get_contract_address
    };
    use openzeppelin_token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
    use core::hash::{LegacyHash, HashStateTrait};
    use core::pedersen::PedersenTrait;
    use core::traits::Into;
    use core::array::SpanTrait;

    #[storage]
    struct Storage {
        owner: ContractAddress,
        payment_token: IERC20Dispatcher,
        lottery_id: u32,
        active_lottery: LotteryInfo,
        ticket_holders: LegacyMap::<u32, ContractAddress>, 
        user_tickets: LegacyMap::<(u32, ContractAddress), u32>, count
        winners: LegacyMap::<(u32, u32), Winner>, 
        winner_count: LegacyMap::<u32, u32>, 
        prize_distribution: LegacyMap::<(u32, u32), u8>, 
        prize_distribution_count: LegacyMap::<u32, u32>, 
    }

    #[event]
    #[derive(Drop, starknet::Event)]
    enum Event {
        LotteryStarted: LotteryStarted,
        TicketsPurchased: TicketsPurchased,
        LotteryEnded: LotteryEnded,
        PrizeClaimed: PrizeClaimed,
    }

    #[derive(Drop, starknet::Event)]
    struct LotteryStarted {
        lottery_id: u32,
        ticket_price: u256,
        max_tickets: u32,
        duration: u64,
    }

    #[derive(Drop, starknet::Event)]
    struct TicketsPurchased {
        lottery_id: u32,
        buyer: ContractAddress,
        ticket_count: u32,
        total_cost: u256,
    }

    #[derive(Drop, starknet::Event)]
    struct LotteryEnded {
        lottery_id: u32,
        total_tickets_sold: u32,
        prize_pool: u256,
        timestamp: u64,
    }

    #[derive(Drop, starknet::Event)]
    struct PrizeClaimed {
        lottery_id: u32,
        winner: ContractAddress,
        prize_amount: u256,
    }

    #[constructor]
    fn constructor(
        ref self: ContractState,
        payment_token_address: ContractAddress,
    ) {
        self.owner.write(get_caller_address());
        self.payment_token.write(IERC20Dispatcher { contract_address: payment_token_address });
        self.lottery_id.write(0);
    }

    #[abi(embed_v0)]
    impl LotteryContractImpl of super::ILotteryContract<ContractState> {
        fn start_lottery(
            ref self: ContractState, 
            ticket_price: u256, 
            max_tickets: u32,
            prize_distribution: Array<u8>,
            duration: u64
        ) {
            self.assert_only_owner();
            
            assert(!self.is_lottery_active(@self), Errors::LOTTERY_ALREADY_ACTIVE);
            
            assert(ticket_price > 0, Errors::INVALID_TICKET_PRICE);
            assert(max_tickets > 0, Errors::INVALID_MAX_TICKETS);
            assert(duration > 0, Errors::INVALID_DURATION);
            
            let mut total_percentage: u8 = 0;
            let mut i: u32 = 0;
            let distribution_len = prize_distribution.len();
            assert(distribution_len > 0, Errors::INVALID_DISTRIBUTION);

            let distribution_span = prize_distribution.span();
            loop {
                if i >= distribution_len {
                    break;
                }
                let percentage = *distribution_span.at(i);
                total_percentage += percentage;
                self.prize_distribution.write((self.lottery_id.read() + 1, i), percentage);
                i += 1;
            }
            
            assert(total_percentage == 100, Errors::INVALID_DISTRIBUTION);
            self.prize_distribution_count.write(self.lottery_id.read() + 1, distribution_len);
            
            let new_lottery_id = self.lottery_id.read() + 1;
            let start_time = get_block_timestamp();
            let end_time = start_time + duration;
            
            self.active_lottery.write(LotteryInfo {
                lottery_id: new_lottery_id,
                ticket_price,
                max_tickets,
                tickets_sold: 0,
                prize_pool: 0,
                start_time,
                end_time,
                lottery_status: 1,
            });
            
            self.lottery_id.write(new_lottery_id);
            
            self.emit(LotteryStarted {
                lottery_id: new_lottery_id,
                ticket_price,
                max_tickets,
                duration,
            });
        }

        fn buy_tickets(ref self: ContractState, ticket_count: u32) {
            assert(self.is_lottery_active(@self), Errors::LOTTERY_NOT_ACTIVE);
            
            let caller = get_caller_address();
            let active_lottery = self.active_lottery.read();
            
            assert(active_lottery.tickets_sold + ticket_count <= active_lottery.max_tickets, Errors::MAX_TICKETS_REACHED);
            
            let total_cost = active_lottery.ticket_price * ticket_count.into();
            
            self.payment_token.read().transfer_from(
                caller, 
                get_contract_address(), 
                total_cost
            );
            
            let current_tickets_sold = active_lottery.tickets_sold;
        
            let mut i: u32 = 0;
            loop {
                if i >= ticket_count {
                    break;
                }
                self.ticket_holders.write(current_tickets_sold + i, caller);
                i += 1;
            }
            
            let user_current_tickets = self.user_tickets.read((active_lottery.lottery_id, caller));
            self.user_tickets.write((active_lottery.lottery_id, caller), user_current_tickets + ticket_count);
            
            self.active_lottery.write(LotteryInfo {
                lottery_id: active_lottery.lottery_id,
                ticket_price: active_lottery.ticket_price,
                max_tickets: active_lottery.max_tickets,
                tickets_sold: active_lottery.tickets_sold + ticket_count,
                prize_pool: active_lottery.prize_pool + total_cost,
                start_time: active_lottery.start_time,
                end_time: active_lottery.end_time,
                lottery_status: active_lottery.lottery_status,
            });
            
            self.emit(TicketsPurchased {
                lottery_id: active_lottery.lottery_id,
                buyer: caller,
                ticket_count,
                total_cost,
            });
        }

        fn end_lottery(ref self: ContractState, random_seed: felt252) {
            self.assert_only_owner();
            
            assert(self.is_lottery_active(@self), Errors::LOTTERY_NOT_ACTIVE);
            
            let active_lottery = self.active_lottery.read();
        
            assert(
                get_block_timestamp() >= active_lottery.end_time || 
                active_lottery.tickets_sold == active_lottery.max_tickets,
                Errors::LOTTERY_NOT_ENDED
            );
            
            if active_lottery.tickets_sold == 0 {
                self.active_lottery.write(LotteryInfo {
                    lottery_id: active_lottery.lottery_id,
                    ticket_price: active_lottery.ticket_price,
                    max_tickets: active_lottery.max_tickets,
                    tickets_sold: active_lottery.tickets_sold,
                    prize_pool: active_lottery.prize_pool,
                    start_time: active_lottery.start_time,
                    end_time: active_lottery.end_time,
                    lottery_status: 2, 
                });
                return;
            }

            let random_value = self.generate_random_value(random_seed);
            
            let prize_pool = active_lottery.prize_pool;
            let mut winner_count: u32 = 0;
            let distribution_count = self.prize_distribution_count.read(active_lottery.lottery_id);
            
            let mut i: u32 = 0;
            loop {
                if i >= distribution_count {
                    break;
                }
                
                let percentage = self.prize_distribution.read((active_lottery.lottery_id, i));
                let prize_amount = (prize_pool * percentage.into()) / 100_u256;
                
                if prize_amount > 0 {
                    let winner_ticket = self.select_random_ticket(
                        active_lottery.tickets_sold, 
                        random_value, 
                        i
                    );
                    let winner_address = self.ticket_holders.read(winner_ticket);
                    
                    self.winners.write(
                        (active_lottery.lottery_id, i),
                        Winner { 
                            address: winner_address, 
                            prize_amount,
                            claimed: false 
                        }
                    );
                    
                    winner_count += 1;
                }
                
                i += 1;
            }
            
            self.winner_count.write(active_lottery.lottery_id, winner_count);
            
            self.active_lottery.write(LotteryInfo {
                lottery_id: active_lottery.lottery_id,
                ticket_price: active_lottery.ticket_price,
                max_tickets: active_lottery.max_tickets,
                tickets_sold: active_lottery.tickets_sold,
                prize_pool: active_lottery.prize_pool,
                start_time: active_lottery.start_time,
                end_time: active_lottery.end_time,
                lottery_status: 2, 
            });
            
            self.emit(LotteryEnded {
                lottery_id: active_lottery.lottery_id,
                total_tickets_sold: active_lottery.tickets_sold,
                prize_pool: active_lottery.prize_pool,
                timestamp: get_block_timestamp(),
            });
        }

        fn claim_prize(ref self: ContractState) {
            let active_lottery = self.active_lottery.read();
            let caller = get_caller_address();
            
            assert(active_lottery.lottery_status >= 2, Errors::LOTTERY_NOT_ENDED);
            
            let lottery_id = active_lottery.lottery_id;
            let winner_count = self.winner_count.read(lottery_id);
            
            let mut prize_found = false;
            let mut total_prize: u256 = 0;
            let mut i: u32 = 0;
            
            loop {
                if i >= winner_count {
                    break;
                }
                
                let winner = self.winners.read((lottery_id, i));
                if winner.address == caller && !winner.claimed {
                    prize_found = true;
                    total_prize += winner.prize_amount;
                    
                    self.winners.write(
                        (lottery_id, i),
                        Winner { 
                            address: winner.address, 
                            prize_amount: winner.prize_amount,
                            claimed: true 
                        }
                    );
                }
                
                i += 1;
            }
            
            assert(prize_found, Errors::NO_PRIZES_TO_CLAIM);
            assert(total_prize > 0, Errors::NO_PRIZES_TO_CLAIM);
            
            self.payment_token.read().transfer(caller, total_prize);
            
            self.emit(PrizeClaimed {
                lottery_id,
                winner: caller,
                prize_amount: total_prize,
            });
        }

        fn get_lottery_info(self: @ContractState) -> LotteryInfo {
            self.active_lottery.read()
        }

        fn get_ticket_holders(self: @ContractState) -> Array<ContractAddress> {
            let active_lottery = self.active_lottery.read();
            let mut holders = ArrayTrait::new();
            let mut i: u32 = 0;
            
            loop {
                if i >= active_lottery.tickets_sold {
                    break;
                }
                
                holders.append(self.ticket_holders.read(i));
                i += 1;
            }
            
            holders
        }

        fn get_winners(self: @ContractState) -> Array<Winner> {
            let active_lottery = self.active_lottery.read();
            let lottery_id = active_lottery.lottery_id;
            let winner_count = self.winner_count.read(lottery_id);
            let mut winners = ArrayTrait::new();
            let mut i: u32 = 0;
            
            loop {
                if i >= winner_count {
                    break;
                }
                
                winners.append(self.winners.read((lottery_id, i)));
                i += 1;
            }
            
            winners
        }

        fn get_user_tickets(self: @ContractState, user: ContractAddress) -> u32 {
            let active_lottery = self.active_lottery.read();
            self.user_tickets.read((active_lottery.lottery_id, user))
        }

        fn is_lottery_active(self: @ContractState) -> bool {
            let active_lottery = self.active_lottery.read();
            active_lottery.lottery_status == 1
        }
    }

    #[generate_trait]
    impl PrivateFunctions of PrivateFunctionsTrait {
        fn assert_only_owner(self: @ContractState) {
            let caller = get_caller_address();
            let owner = self.owner.read();
            assert(caller == owner, Errors::NOT_OWNER);
        }

        fn generate_random_value(self: @ContractState, seed: felt252) -> felt252 {
            let block_number = get_block_number();
            let block_timestamp = get_block_timestamp();
            let tx_info = get_tx_info().unbox();
            let tx_hash = tx_info.transaction_hash;
            
            let mut hash_state = PedersenTrait::new(0);
            hash_state = hash_state.update(seed);
            hash_state = hash_state.update(block_number.into());
            hash_state = hash_state.update(block_timestamp.into());
            hash_state = hash_state.update(tx_hash);
            
            hash_state.finalize()
        }

        fn select_random_ticket(
            self: @ContractState,
            total_tickets: u32,
            random_value: felt252,
            offset: u32
        ) -> u32 {
    
            let mut hash_state = PedersenTrait::new(0);
            hash_state = hash_state.update(random_value);
            hash_state = hash_state.update(offset.into());
            let new_random = hash_state.finalize();
            
            (new_random.try_into().unwrap() % total_tickets.into()).try_into().unwrap()
        }
    }
}
}

Cairo Academy: Understanding a Basic DAO Contract

This chapter explores a fundamental DAO (Decentralized Autonomous Organization) contract implemented in Cairo. This contract demonstrates core DAO functionalities, providing a practical example for learning how to build decentralized governance systems on StarkNet.

Purpose and Functionality

The provided Cairo code defines a basic DAO contract with the following capabilities:

• Proposal Management: Create, vote on, and execute governance proposals
• Membership Control: Add and remove members with voting power
• Voting System: Track votes for and against proposals
• Governance Rules: Enforce voting periods and execution conditions

Key Components

Data Structures

#![allow(unused)]
fn main() {
#[derive(Copy, Drop, Hash)]
struct ProposalId {
    id: u64
}

#[derive(Copy, Drop, Serde, starknet::Store)]
struct Proposal {
    proposer: ContractAddress,
    description: felt252,
    for_votes: u256,
    against_votes: u256,
    start_block: u64,
    end_block: u64,
    executed: bool
}

#[derive(Copy, Drop, Serde, starknet::Store)]
struct Member {
    address: ContractAddress,
    voting_power: u256
}
}

Core Functionalities

1. Proposal Creation:

   • Only members can create proposals
   • Each proposal has a 100-block voting period
   • Proposals store vote counts and execution status

2. Voting Mechanism:

   • Members vote with their voting power
   • Votes can be for or against proposals
   • Voting is only allowed during the active period

3. Proposal Execution:

   • Can only execute after voting period ends
   • Requires more for-votes than against-votes
   • Prevents double execution

4. Membership Management:

   • Admin-controlled member additions/removals
   • Members have associated voting power

Interface Definition

#![allow(unused)]
fn main() {
#[starknet::interface]
pub trait IDAO<TContractState> {
    fn create_proposal(ref self: TContractState, description: felt252);
    fn vote(ref self: TContractState, proposal_id: ProposalId, support: bool);
    fn execute_proposal(ref self: TContractState, proposal_id: ProposalId);
    fn add_member(ref self: TContractState, member: ContractAddress, voting_power: u256);
    fn remove_member(ref self: TContractState, member: ContractAddress);
    fn get_proposal(self: @TContractState, proposal_id: ProposalId) -> Proposal;
    fn get_member(self: @TContractState, member: ContractAddress) -> Member;
}
}

Event System

#![allow(unused)]
fn main() {
#[event]
enum Event {
    ProposalCreated: ProposalCreatedEvent,
    Voted: VotedEvent,
    ProposalExecuted: ProposalExecutedEvent,
    MemberAdded: MemberAddedEvent,
    MemberRemoved: MemberRemovedEvent
}
}

Security Features

• Member verification for proposal creation
• Voting period enforcement
• Execution condition checks
• Admin-only member management

Usage Example

• Admin adds members with add_member
• Members create proposals with create_proposal
• Other members vote with vote
• After voting period, anyone can execute_proposal if it passed

Full Implementation

#![allow(unused)]
fn main() {
use core::num::traits::Zero;
use starknet::ContractAddress;

#[derive(Copy, Drop, Hash)]
struct ProposalId {
    id: u64
}

#[derive(Copy, Drop, Serde, starknet::Store)]
struct Proposal {
    proposer: ContractAddress,
    description: felt252,
    for_votes: u256,
    against_votes: u256,
    start_block: u64,
    end_block: u64,
    executed: bool
}

#[derive(Copy, Drop, Serde, starknet::Store)]
struct Member {
    address: ContractAddress,
    voting_power: u256
}

#[starknet::interface]
pub trait IDAO<TContractState> {
    fn create_proposal(ref self: TContractState, description: felt252);
    fn vote(ref self: TContractState, proposal_id: ProposalId, support: bool);
    fn execute_proposal(ref self: TContractState, proposal_id: ProposalId);
    fn add_member(ref self: TContractState, member: ContractAddress, voting_power: u256);
    fn remove_member(ref self: TContractState, member: ContractAddress);
    fn get_proposal(self: @TContractState, proposal_id: ProposalId) -> Proposal;
    fn get_member(self: @TContractState, member: ContractAddress) -> Member;
}

#[starknet::contract]
mod dao {
    use core::num::traits::Zero;
    use starknet::{ContractAddress, get_caller_address, get_block_number};
    use super::{IDAO, ProposalId, Proposal, Member};

    #[storage]
    struct Storage {
        proposals: LegacyMap<ProposalId, Proposal>,
        members: LegacyMap<ContractAddress, Member>,
        next_proposal_id: u64
    }

    #[event]
    enum Event {
        ProposalCreated: ProposalCreatedEvent,
        Voted: VotedEvent,
        ProposalExecuted: ProposalExecutedEvent,
        MemberAdded: MemberAddedEvent,
        MemberRemoved: MemberRemovedEvent
    }

    #[derive(Drop, Serde)]
    struct ProposalCreatedEvent {
        proposal_id: ProposalId,
        proposer: ContractAddress,
        description: felt252,
        start_block: u64,
        end_block: u64
    }

    #[derive(Drop, Serde)]
    struct VotedEvent {
        proposal_id: ProposalId,
        voter: ContractAddress,
        support: bool
    }

    #[derive(Drop, Serde)]
    struct ProposalExecutedEvent {
        proposal_id: ProposalId
    }

    #[derive(Drop, Serde)]
    struct MemberAddedEvent {
        member: ContractAddress,
        voting_power: u256
    }

    #[derive(Drop, Serde)]
    struct MemberRemovedEvent {
        member: ContractAddress
    }

    #[abi(embed_v0)]
    impl IDAOImpl of IDAO<ContractState> {
        fn create_proposal(ref self: ContractState, description: felt252) {
            let caller: ContractAddress = get_caller_address();
            let member: Member = self.members.read(caller);

            assert!(member.voting_power > Zero::zero(), "Caller is not a member");

            let proposal_id = ProposalId { id: self.next_proposal_id.read() };
            let start_block = get_block_number();
            let end_block = start_block + 100;

            self.proposals.write(proposal_id, Proposal {
                proposer: caller,
                description,
                for_votes: Zero::zero(),
                against_votes: Zero::zero(),
                start_block,
                end_block,
                executed: false
            });

            self.next_proposal_id.write(self.next_proposal_id.read() + 1);

            self.emit(ProposalCreatedEvent {
                proposal_id,
                proposer: caller,
                description,
                start_block,
                end_block
            });
        }

        fn vote(ref self: ContractState, proposal_id: ProposalId, support: bool) {
            let caller: ContractAddress = get_caller_address();
            let member: Member = self.members.read(caller);
            let mut proposal: Proposal = self.proposals.read(proposal_id);

            assert!(get_block_number() < proposal.end_block, "Voting period has ended");
            assert!(!proposal.executed, "Proposal already executed");

            if support {
                proposal.for_votes += member.voting_power;
            } else {
                proposal.against_votes += member.voting_power;
            }

            self.proposals.write(proposal_id, proposal);

            self.emit(VotedEvent {
                proposal_id,
                voter: caller,
                support
            });
        }

        fn execute_proposal(ref self: ContractState, proposal_id: ProposalId) {
            let proposal: Proposal = self.proposals.read(proposal_id);

            assert!(get_block_number() > proposal.end_block, "Voting period has not ended");
            assert!(!proposal.executed, "Proposal already executed");
            assert!(proposal.for_votes > proposal.against_votes, "Proposal did not pass");

            // Execute the proposal (e.g., transfer funds, update state, etc.)
            // Placeholder for proposal execution logic

            self.proposals.write(proposal_id, Proposal { executed: true, ..proposal });

            self.emit(ProposalExecutedEvent { proposal_id });
        }

        fn add_member(ref self: ContractState, member: ContractAddress, voting_power: u256) {
            let caller: ContractAddress = get_caller_address();
            assert!(caller == self.admin.read(), "Only admin can add members");

            self.members.write(member, Member { address: member, voting_power });

            self.emit(MemberAddedEvent { member, voting_power });
        }

        fn remove_member(ref self: ContractState, member: ContractAddress) {
            let caller: ContractAddress = get_caller_address();
            assert!(caller == self.admin.read(), "Only admin can remove members");

            self.members.write(member, Member { address: member, voting_power: Zero::zero() });

            self.emit(MemberRemovedEvent { member });
        }

        fn get_proposal(self: @ContractState, proposal_id: ProposalId) -> Proposal {
            self.proposals.read(proposal_id)
        }

        fn get_member(self: @ContractState, member: ContractAddress) -> Member {
            self.members.read(member)
        }
    }
}
}

This contract serves as a foundation for building more complex DAO systems on StarkNet, demonstrating key concepts like decentralized governance and member voting.

Cairo Academy: Understanding an Escrow Contract

This chapter explores an Escrow contract implemented in Cairo. This contract demonstrates a secure token exchange mechanism between two parties, providing a trustless way to facilitate transactions on StarkNet.

Purpose and Functionality

The provided Cairo code defines an escrow contract with the following capabilities:

• Token Escrow: Lock tokens from sender until conditions are met
• Time-Locked Refunds: Allow sender to reclaim tokens after timeout
• Secure Execution: Recipient can execute the trade when ready
• Status Examination: View escrow details at any time

Key Components

Data Structures

#![allow(unused)]
fn main() {
#[derive(Copy, Drop, Hash)]
struct EscrowId {
    sender: ContractAddress,
    recipient: ContractAddress,
    in_token: ContractAddress
}

#[derive(Copy, Default, Drop, Serde, starknet::Store)]
pub struct EscrowDetails {
    pub in_amount: u256,
    pub out_token: ContractAddress,
    pub out_amount: u256,
    pub created_at: u64, 
}
}

Core Functionalities

1. Escrow Creation:

   • Sender locks input tokens into the contract
   • Specifies recipient and expected output tokens
   • Records creation timestamp for refund timing

2. Escrow Execution:

   • Recipient can execute the trade when ready
   • Atomic swap of input and output tokens
   • Only the specified recipient can execute

3. Refund Mechanism:

   • Sender can reclaim tokens after 7 days
   • Prevents indefinite locking of funds
   • Only available after timeout period

4. Status Checking:

   • Anyone can examine escrow details
   • View token amounts and timestamps
   • No state modification

Interface Definition

#![allow(unused)]
fn main() {
#[starknet::interface]
pub trait IEscrow<TContractState> {
    fn examine(
        self: @TContractState, sender: ContractAddress, recipient: ContractAddress, in_token: ContractAddress
    ) -> EscrowDetails;

    fn enter(
        ref self: TContractState,
        recipient: ContractAddress,
        in_token: ContractAddress,
        in_amount: u256,
        out_token: ContractAddress,
        out_amount: u256
    );

    fn exit(ref self: TContractState, sender: ContractAddress, recipient: ContractAddress, in_token: ContractAddress);

    fn execute(ref self: TContractState, sender: ContractAddress, in_token: ContractAddress);
}
}

Event System

#![allow(unused)]
fn main() {
#[event]
enum Event {
    EscrowCreated: EscrowCreatedEvent,
    EscrowExecuted: EscrowExecutedEvent,
    EscrowRefunded: EscrowRefundedEvent
}
}

Security Features

• Token transfers use StarkNet's native token standards
• Time-locked refunds prevent indefinite locking
• Only specified recipient can execute
• Only original sender can refund
• Atomic swap ensures both sides complete or none do

Usage Example

1. Creating an Escrow:

#![allow(unused)]
fn main() {
// Alice wants to trade 100 TOKA for 200 TOKB with Bob
escrow.enter(
    bob_address,
    token_a_address,
    100,
    token_b_address,
    200
);
}

2. Executing the Trade:

#![allow(unused)]
fn main() {
// When Bob is ready, he executes the escrow
escrow.execute(alice_address, token_a_address);
}

3. Refunding:

#![allow(unused)]
fn main() {
// If Bob doesn't complete within 7 days, Alice can refund
escrow.exit(alice_address, bob_address, token_a_address);
}

Full Implementation

#![allow(unused)]
fn main() {
use core::num::traits::Zero;
use starknet::ContractAddress;

#[derive(Copy, Drop, Hash)]
struct EscrowId {
    sender: ContractAddress,
    recipient: ContractAddress,
    in_token: ContractAddress
}

#[derive(Copy, Default, Drop, Serde, starknet::Store)]
pub struct EscrowDetails {
    pub in_amount: u256,
    pub out_token: ContractAddress,
    pub out_amount: u256,
    pub created_at: u64, 
}

#[starknet::interface]
pub trait IEscrow<TContractState> {
    fn examine(
        self: @TContractState, sender: ContractAddress, recipient: ContractAddress, in_token: ContractAddress
    ) -> EscrowDetails;

    fn enter(
        ref self: TContractState,
        recipient: ContractAddress,
        in_token: ContractAddress,
        in_amount: u256,
        out_token: ContractAddress,
        out_amount: u256
    );

    fn exit(ref self: TContractState, sender: ContractAddress, recipient: ContractAddress, in_token: ContractAddress);

    fn execute(ref self: TContractState, sender: ContractAddress, in_token: ContractAddress);
}

#[starknet::interface]
trait IERC20<TContractState> {
    fn transfer(ref self: TContractState, to: ContractAddress, amount: u256);
    fn transfer_from(
        ref self: TContractState, from: ContractAddress, to: ContractAddress, amount: u256
    );
}

impl ContractAddressDefault of Default<ContractAddress> {
    fn default() -> ContractAddress {
        Zero::zero()
    }
}

impl EscrowDetailsZero of Zero<EscrowDetails> {
    fn zero() -> EscrowDetails {
        EscrowDetails { in_amount: Zero::zero(), out_token: Zero::zero(), out_amount: Zero::zero(), created_at: 0 }
    }

    fn is_zero(self: @EscrowDetails) -> bool {
        self.in_amount.is_zero() && self.out_token.is_zero() && self.out_amount.is_zero()
    }

    fn is_non_zero(self: @EscrowDetails) -> bool {
        !self.is_zero()
    }
}

#[starknet::contract]
mod escrow {
    use core::num::traits::Zero;
    use starknet::{ContractAddress, get_caller_address, get_contract_address, get_block_timestamp};
    use super::{IEscrow, IERC20Dispatcher, IERC20DispatcherTrait};
    use super::{ContractAddressDefault, EscrowDetails, EscrowId};

    #[storage]
    struct Storage {
        escrows: LegacyMap<EscrowId, EscrowDetails>
    }

    #[event]
    enum Event {
        EscrowCreated: EscrowCreatedEvent,
        EscrowExecuted: EscrowExecutedEvent,
        EscrowRefunded: EscrowRefundedEvent
    }

    #[derive(Drop, Serde)]
    struct EscrowCreatedEvent {
        sender: ContractAddress,
        recipient: ContractAddress,
        in_token: ContractAddress,
        in_amount: u256,
        out_token: ContractAddress,
        out_amount: u256
    }

    #[derive(Drop, Serde)]
    struct EscrowExecutedEvent {
        sender: ContractAddress,
        recipient: ContractAddress,
        in_token: ContractAddress,
        in_amount: u256,
        out_token: ContractAddress,
        out_amount: u256
    }

    #[derive(Drop, Serde)]
    struct EscrowRefundedEvent {
        sender: ContractAddress,
        recipient: ContractAddress,
        in_token: ContractAddress,
        in_amount: u256
    }

    #[abi(embed_v0)]
    impl IEscrowImpl of IEscrow<ContractState> {
        fn examine(
            self: @ContractState, sender: ContractAddress, recipient: ContractAddress, in_token: ContractAddress
        ) -> EscrowDetails {
            self.escrows.read(EscrowId { sender, recipient, in_token })
        }

        fn enter(
            ref self: ContractState,
            recipient: ContractAddress,
            in_token: ContractAddress,
            in_amount: u256,
            out_token: ContractAddress,
            out_amount: u256
        ) {
            let caller: ContractAddress = get_caller_address();
            let escrow_id = EscrowId { sender: caller, recipient, in_token };
            let escrow_details: EscrowDetails = self.escrows.read(escrow_id);

            assert!(escrow_details.is_zero(), "escrow already exists");
            assert!(in_amount > Zero::zero(), "amount must be positive");
            assert!(out_amount > Zero::zero(), "amount must be positive");

            let created_at = get_block_timestamp();
            self.escrows.write(escrow_id, EscrowDetails { in_amount, out_token, out_amount, created_at });

            IERC20Dispatcher { contract_address: in_token }
                .transfer_from(caller, get_contract_address(), in_amount);

            self.emit(EscrowCreatedEvent { 
                sender: caller, 
                recipient, 
                in_token, 
                in_amount, 
                out_token, 
                out_amount 
            });
        }

        fn exit(ref self: ContractState, sender: ContractAddress, recipient: ContractAddress, in_token: ContractAddress) {
            let caller: ContractAddress = get_caller_address();
            let escrow_id = EscrowId { sender: caller, recipient, in_token };
            let escrow_details = self.escrows.read(escrow_id);

            assert!(escrow_details.is_non_zero(), "escrow does not exist");
            assert!(caller == sender, "only sender can refund");

            let current_time = get_block_timestamp();
            assert!(current_time > escrow_details.created_at + 7 * 24 * 60 * 60, "escrow cannot be refunded yet");

            self.escrows.write(escrow_id, Default::default());

            IERC20Dispatcher { contract_address: in_token }.transfer(caller, escrow_details.in_amount);

            self.emit(EscrowRefundedEvent { 
                sender: caller, 
                recipient, 
                in_token, 
                in_amount: escrow_details.in_amount 
            });
        }

        fn execute(ref self: ContractState, sender: ContractAddress, in_token: ContractAddress) {
            let caller: ContractAddress = get_caller_address();
            let escrow_id = EscrowId { sender, recipient: caller, in_token };
            let escrow_details: EscrowDetails = self.escrows.read(escrow_id);

            assert!(escrow_details.is_non_zero(), "escrow does not exist");
            assert!(caller == escrow_id.recipient, "only recipient can execute");

            self.escrows.write(escrow_id, Default::default());

            // Transfer locked tokens to recipient
            IERC20Dispatcher { contract_address: escrow_id.in_token }
                .transfer(caller, escrow_details.in_amount);
            
            // Transfer expected tokens from recipient to sender
            IERC20Dispatcher { contract_address: escrow_details.out_token }
                .transfer_from(caller, sender, escrow_details.out_amount);

            self.emit(EscrowExecutedEvent { 
                sender, 
                recipient: caller, 
                in_token, 
                in_amount: escrow_details.in_amount, 
                out_token: escrow_details.out_token, 
                out_amount: escrow_details.out_amount 
            });
        }
    }
}
}

This contract serves as a foundation for building secure token exchange systems on StarkNet, demonstrating key concepts like atomic swaps and time-locked transactions.

Cairo Academy: Understanding a Basic NFT Auction Contract

This chapter delves into the basics of an NFT Auction Contract implemented in Cairo. This contract demonstrates the core functionalities of a NFT Auction Contract, providing a practical example for learning how to build a basic NFT Auction Contract on StarkNet.

Purpose and Functionality

The provided Cairo code defines a NFT Auction Contract. It implements essential functionalities of ERC20 such as:

• Get Name: This function returns the name of the token
• Get Symbol: This function returns the symbol or ticker of the token
• Get Decimal: This function returns the number of decimal the token uses
• Get Total Supply This function returns the total number of tokens in existence
• Get Balance: This function returns the number of tokens owned by a specified account. This takes a parameter: account : This stores the token
• Allowance: This function returns the amount of tokens that a spender is allowed to spend on behalf of an owner. This takes parameters: owner : This is the account owner spender : Authorized person to spend on behalf of the owner
• Tranfer: This function transfers a specified amount of tokens from the caller's account to the recipient. This takes parameter: recipient: This is the reciever of the token and the account: This stores the token
• Transfer From: This function transfers amount of tokens from sender to recipient using the allowance mechanism. The caller must have an allowance for the sender's tokens of at least amount. This takes parameters: sender, recipient and amount
• Approve: This function allows the caller to set the amount that a spender is authorized to spend on their behalf.
• Increase Allowance: This function increases the allowance of spender by added_value.
• Decrease Allowance: This function decreases the allowance of spender by subtracted_value

#![allow(unused)]
fn main() {
use starknet::ContractAddress;
}

#![allow(unused)]
fn main() {
#[starknet::interface]
pub trait IERC20<TContractState> {
    fn get_name(self: @TContractState) -> felt252;
    fn get_symbol(self: @TContractState) -> felt252;
    fn get_decimals(self: @TContractState) -> u8;
    fn get_total_supply(self: @TContractState) -> felt252;
    fn balance_of(self: @TContractState, account: ContractAddress) -> felt252;
    fn allowance(
        self: @TContractState, owner: ContractAddress, spender: ContractAddress,
    ) -> felt252;
    fn transfer(ref self: TContractState, recipient: ContractAddress, amount: felt252);
    fn transfer_from(
        ref self: TContractState,
        sender: ContractAddress,
        recipient: ContractAddress,
        amount: felt252,
    );
    fn approve(ref self: TContractState, spender: ContractAddress, amount: felt252);
    fn increase_allowance(ref self: TContractState, spender: ContractAddress, added_value: felt252);
    fn decrease_allowance(
        ref self: TContractState, spender: ContractAddress, subtracted_value: felt252,
    );
}
}

This NFT Auction Contract implements essential functionalities of IERC721 such as:

• Get Name: This function returns the name of the NFT (eg Cairo Academy Token)
• Get Symbol: This function returns the symbol of the NFT token (e.g., "CAT")
• Get Token URI: This function returns the Uniform Resource Identifier (URI) for a specific token ID. This takes parameter: token_id : This is specific token identification
• Get Balance: This function returns the number of NFTs owned by a specific account. This takes parameter: account : This holds the NFT value
• Get Approval: This function returns the address that has been approved to transfer a specific token ID. This takes parameter: token_id
• Is Approved for All: This function checks if an operator has been approved to manage all of the tokens for a given owner. This takes parameter: owner and operator
• Approve: This function allows the owner of a token to approve another address (to) to transfer the token (token_id). This takes parameter: token_id and an address
• Set Is Approved for All: This function enables or disables approval for an operator to manage all of the caller’s assets. This takes parameter: operator and a bool (true/false)
• Transfer from: This function transfers the ownership of a specific token (token_id) from one address (from) to another address (to). The caller must be approved to make this transfer. This takes parameter: token_id, address (from) and address (to)
• Mint: This function creates a new token (token_id) and assigns it to a specific address (to). This takes parameter: token_id and an address

#![allow(unused)]
fn main() {
#[starknet::interface]
trait IERC721<TContractState> {
    fn get_name(self: @TContractState) -> felt252;
    fn get_symbol(self: @TContractState) -> felt252;
    fn get_token_uri(self: @TContractState, token_id: u256) -> felt252;
    fn balance_of(self: @TContractState, account: ContractAddress) -> u256;
    fn owner_of(self: @TContractState, token_id: u256) -> ContractAddress;
    fn get_approved(self: @TContractState, token_id: u256) -> ContractAddress;
    fn is_approved_for_all(
        self: @TContractState, owner: ContractAddress, operator: ContractAddress,
    ) -> bool;
    fn approve(ref self: TContractState, to: ContractAddress, token_id: u256);
    fn set_approval_for_all(ref self: TContractState, operator: ContractAddress, approved: bool);
    fn transfer_from(
        ref self: TContractState, from: ContractAddress, to: ContractAddress, token_id: u256,
    );
    fn mint(ref self: TContractState, to: ContractAddress, token_id: u256);
}
}

This NFT Auction Contract also implements Buy and Get Price functions. This functions buys and gets price of the NFTs

#![allow(unused)]
fn main() {
pub trait INFTAuction<TContractState> {
    fn buy(ref self: TContractState, token_id: u256);
    fn get_price(self: @TContractState) -> u64;
}
}

Implementation

#![allow(unused)]
fn main() {
#[starknet::contract]
pub mod NFTAuction {
    use super::{IERC20Dispatcher, IERC20DispatcherTrait, IERC721Dispatcher, IERC721DispatcherTrait};
    use starknet::{ContractAddress, get_caller_address, get_block_timestamp};
    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
 
    #[storage]
    struct Storage {
        erc20_token: ContractAddress,
        erc721_token: ContractAddress,
        starting_price: u64,
        seller: ContractAddress,
        duration: u64,
        discount_rate: u64,
        start_at: u64,
        expires_at: u64,
        purchase_count: u128,
        total_supply: u128,
    }
 
    mod Errors {
        pub const AUCTION_ENDED: felt252 = 'auction has ended';
        pub const LOW_STARTING_PRICE: felt252 = 'low starting price';
        pub const INSUFFICIENT_BALANCE: felt252 = 'insufficient balance';
    }
 
    #[constructor]
    fn constructor(
        ref self: ContractState,
        erc20_token: ContractAddress,
        erc721_token: ContractAddress,
        starting_price: u64,
        seller: ContractAddress,
        duration: u64,
        discount_rate: u64,
        total_supply: u128,
    ) {
        assert(starting_price >= discount_rate * duration, Errors::LOW_STARTING_PRICE);
 
        self.erc20_token.write(erc20_token);
        self.erc721_token.write(erc721_token);
        self.starting_price.write(starting_price);
        self.seller.write(seller);
        self.duration.write(duration);
        self.discount_rate.write(discount_rate);
        self.start_at.write(get_block_timestamp());
        self.expires_at.write(get_block_timestamp() + duration * 1000);
        self.total_supply.write(total_supply);
    }
 
    #[abi(embed_v0)]
    impl NFTDutchAuction of super::INFTAuction<ContractState> {
        fn get_price(self: @ContractState) -> u64 {
            let time_elapsed = (get_block_timestamp() - self.start_at.read())
                / 1000; // Ignore milliseconds
            let discount = self.discount_rate.read() * time_elapsed;
            self.starting_price.read() - discount
        }
 
        fn buy(ref self: ContractState, token_id: u256) {
            // Check duration
            assert(get_block_timestamp() < self.expires_at.read(), Errors::AUCTION_ENDED);
            // Check total supply
            assert(self.purchase_count.read() < self.total_supply.read(), Errors::AUCTION_ENDED);
 
            let erc20_dispatcher = IERC20Dispatcher { contract_address: self.erc20_token.read() };
            let erc721_dispatcher = IERC721Dispatcher {
                contract_address: self.erc721_token.read(),
            };
 
            let caller = get_caller_address();
            // Get NFT price
            let price: u256 = self.get_price().into();
            let buyer_balance: u256 = erc20_dispatcher.balance_of(caller).into();
            // Ensure buyer has enough token for payment
            assert(buyer_balance >= price, Errors::INSUFFICIENT_BALANCE);
            // Transfer payment token from buyer to seller
            erc20_dispatcher.transfer_from(caller, self.seller.read(), price.try_into().unwrap());
            // Mint token to buyer's address
            erc721_dispatcher.mint(caller, token_id);
            // Increase purchase count
            self.purchase_count.write(self.purchase_count.read() + 1);
        }
    }
}
}

Cairo Academy: Understanding a Marketplace Contract

This chapter delves into the basics of a Marketplace contract implemented in Cairo. This contract demonstrates the core functionalities of a basic Marketplace contract, providing a practical example for learning how to build a basic Marketplace contract on StarkNet.

Purpose and Functionality

The provided Cairo code defines a basic lottery contract. It implements essential Marketplace, ERC20 and IERC721, IERC1155 functionalities

#![allow(unused)]
fn main() {
use starknet::ContractAddress;
}

Marketplace functionalities

• list_asset: This creates new listing with nft ownership verification. This has parameters: asset_contract, token_id, start_time, duration, quantity, payment_token, price_per_token, asset_type
• remove_listing: This removes listing by replacing with empty listing. This has parameters: token_id
• purchase: Direct purchase at listed price. This has parameters: listing_id, recipient, quantity, payment_token, total_price
• accept_bid: Seller accepts a specific offer. This has parameters: listing_id, bidder, payment_token, price_per_token
• place_bid: Places a bid/offer on an existing listing. This has parameters: listing_id, quantity, payment_token, price_per_token, expiration
• modify_listing: Modify existing listing parameters. This has parameters: listing_id, quantity, reserve_price, buy_now_price, payment_token, start_time, duration
• get_listing_count: Returns total number of listings created.

#![allow(unused)]
fn main() {
#[starknet::interface]
trait IMarketplace<TContractState> {
    fn list_asset(
        ref self: TContractState,
        asset_contract: ContractAddress,
        token_id: u256,
        start_time: u256,
        duration: u256,
        quantity: u256,
        payment_token: ContractAddress,
        price_per_token: u256,
        asset_type: u256,
    );  
    fn remove_listing(ref self: TContractState, listing_id: u256);
    fn purchase(
        ref self: TContractState,
        listing_id: u256,
        recipient: ContractAddress,
        quantity: u256,
        payment_token: ContractAddress,
        total_price: u256,
    );
    fn accept_bid(
        ref self: TContractState,
        listing_id: u256,
        bidder: ContractAddress,
        payment_token: ContractAddress,
        price_per_token: u256
    );
    fn place_bid(
        ref self: TContractState,
        listing_id: u256,
        quantity: u256,
        payment_token: ContractAddress,
        price_per_token: u256,
        expiration: u256
    );
    fn modify_listing(
        ref self: TContractState,
        listing_id: u256,
        quantity: u256,
        reserve_price: u256,
        buy_now_price: u256,
        payment_token: ContractAddress,
        start_time: u256,
        duration: u256,
    );
    fn get_listing_count(self: @TContractState) -> u256;
}
}

ERC20 functionalities

The IERC20 interface defines the core functions for an ERC20 token contract

• balance_of: This function returns the token balance of a specific account. This has parameters: account: The account parameter is the address of the account whose balance is being queried, and the function returns a u256 representing the amount of tokens owned by that account
• allowance: This function returns the amount of tokens that one account (spender) is authorized to spend on behalf of another account (owner). This has parameters: owner and spender
• transfer: This function transfers a specified amount of tokens from the caller's account to the recipient account. This has parameters: spender, recipient and amount

#![allow(unused)]
fn main() {
#[starknet::interface]
trait IERC20<TContractState> {
    fn balance_of(self: @TContractState, account: ContractAddress) -> u256;
    fn allowance(self: @TContractState, owner: ContractAddress, spender: ContractAddress) -> u256;
    fn transfer(ref self: TContractState, recipient: ContractAddress, amount: u256);
    fn transfer_from(
        ref self: TContractState, sender: ContractAddress, recipient: ContractAddress, amount: u256
    );
}
}

IERC721 functionalities

The IERC721 interface defines the basic functions that an ERC721-compliant contract should implement.ERC721 is a standard for representing non-fungible tokens (NFTs)

• owner_of: This function returns the address of the owner of the NFT represented by token_id. This has parameters: token_id, parameter is a unique identifier for the NFT, and the function returns the ContractAddress of the current owner
• get_approved: This function returns the address that has been approved to manage or transfer the specified NFT (token_id). This takes parameter: token_id
• is_approved_for_all: This function checks whether an operator address has been authorized to manage all NFTs owned by an owner address. This takes parameter: owner and operator.
• transfer_from: This function transfers the ownership of the NFT represented by token_id from the 'from' address to the 'to' address. The function allows a transfer to occur. This has parameters : token_id, two addresses, 'from' and 'to'

#![allow(unused)]
fn main() {
#[starknet::interface]
trait IERC721<TContractState> {
    fn owner_of(self: @TContractState, token_id: u256) -> ContractAddress;
    fn get_approved(self: @TContractState, token_id: u256) -> ContractAddress;
    fn is_approved_for_all(
        self: @TContractState, owner: ContractAddress, operator: ContractAddress
    ) -> bool;
    fn transfer_from(
        ref self: TContractState, from: ContractAddress, to: ContractAddress, token_id: u256
    );
}
}

IERC1155 functionalities

The IERC1155 interface defines the core functions for an ERC1155 token contract. ERC1155 is a token standard that allows a single contract to manage multiple token types, which can be a mix of fungible and non-fungible tokens.

• balance_of: This function returns the balance of a specific token id for a given account. This takes parameter: 'account', the address of the account whose balance is being queried, and the 'id' parameter is the identifier of the token,
• is_approved_for_all: This function checks if an operator is approved to manage all tokens for a given account. This takes parameter: The 'account', the address of the token owner, and the 'operator', the address being checked for approval. The function returns a boolean value: true if the operator is approved for all tokens, and false otherwise.
• safe_transfer_from: This function transfers a specified amount of tokens of type id from the 'from' address to the 'to' address. This takes parameter: Two address 'from', the address from which the tokens are being released and 'to', the address from which the tokens are being sent to. The id is the token identifier, amount is the number of tokens to transfer, and data is additional data to be passed to the recipient.

#![allow(unused)]
fn main() {
#[starknet::interface]
trait IERC1155<TContractState> {
    fn balance_of(self: @TContractState, account: ContractAddress, id: u256) -> u256;
    fn is_approved_for_all(
        self: @TContractState, account: ContractAddress, operator: ContractAddress
    ) -> bool;
    fn safe_transfer_from(
        ref self: TContractState,
        from: ContractAddress,
        to: ContractAddress,
        id: u256,
        amount: u256,
        data: Span<felt252>
    );
}
}

Cairo Academy: Understanding a Stake Contract

This chapter delves into the basics of a staking contract implemented in Cairo. This contract demonstrates the core functionalities of a basic Stake contract, providing a practical example for learning how to build a basic staking contract on StarkNet.

Purpose and Functionality

The provided Cairo code defines a basic Stake contract. It implements essential Staking Contract functionalities

• set_reward_amount This function sets the reward amount. This takes a parameter: amount
• set_reward_duration This function sets the period (time) for the reward to be accessed. This takes parameter: duration
• stake This function allows the staker to stake his digital assets. This takes parameter: amount
• withdraw This function allows for stakes to be taken (withdrawn). This takes parameter: amount
• get_rewards This function computes rewards
• claim_rewards This function makes claiming of rewards possible.

#![allow(unused)]
fn main() {
use starknet::ContractAddress;
 
#[starknet::interface]
pub trait IStakingContract<TContractState> {
    fn set_reward_amount(ref self: TContractState, amount: u256);
    fn set_reward_duration(ref self: TContractState, duration: u256);
    fn stake(ref self: TContractState, amount: u256);
    fn withdraw(ref self: TContractState, amount: u256);
    fn get_rewards(self: @TContractState, account: ContractAddress) -> u256;
    fn claim_rewards(ref self: TContractState);
}
 
mod Errors {
    pub const NULL_REWARDS: felt252 = 'Reward amount must be > 0';
    pub const NOT_ENOUGH_REWARDS: felt252 = 'Reward amount must be > balance';
    pub const NULL_AMOUNT: felt252 = 'Amount must be > 0';
    pub const NULL_DURATION: felt252 = 'Duration must be > 0';
    pub const UNFINISHED_DURATION: felt252 = 'Reward duration not finished';
    pub const NOT_OWNER: felt252 = 'Caller is not the owner';
    pub const NOT_ENOUGH_BALANCE: felt252 = 'Balance too low';
}
 
#[starknet::contract]
pub mod StakingContract {
    use core::starknet::event::EventEmitter;
    use core::num::traits::Zero;
    use starknet::{ContractAddress, get_caller_address, get_block_timestamp, get_contract_address};
    use openzeppelin_token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
    use starknet::storage::{
        Map, StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess,
        StoragePointerWriteAccess,
    };
 
    #[storage]
    struct Storage {
        pub staking_token: IERC20Dispatcher,
        pub reward_token: IERC20Dispatcher,
        pub owner: ContractAddress,
        pub reward_rate: u256,
        pub duration: u256,
        pub current_reward_per_staked_token: u256,
        pub finish_at: u256,
        pub last_updated_at: u256,
        pub last_user_reward_per_staked_token: Map::<ContractAddress, u256>,
        pub unclaimed_rewards: Map::<ContractAddress, u256>,
        pub total_distributed_rewards: u256,
        pub total_supply: u256,
        pub balance_of: Map::<ContractAddress, u256>,
    }
 
    #[event]
    #[derive(Copy, Drop, Debug, PartialEq, starknet::Event)]
    pub enum Event {
        Deposit: Deposit,
        Withdrawal: Withdrawal,
        RewardsFinished: RewardsFinished,
    }
 
    #[derive(Copy, Drop, Debug, PartialEq, starknet::Event)]
    pub struct Deposit {
        pub user: ContractAddress,
        pub amount: u256,
    }
 
    #[derive(Copy, Drop, Debug, PartialEq, starknet::Event)]
    pub struct Withdrawal {
        pub user: ContractAddress,
        pub amount: u256,
    }
 
    #[derive(Copy, Drop, Debug, PartialEq, starknet::Event)]
    pub struct RewardsFinished {
        pub msg: felt252,
    }
 
    #[constructor]
    fn constructor(
        ref self: ContractState,
        staking_token_address: ContractAddress,
        reward_token_address: ContractAddress,
    ) {
        self.staking_token.write(IERC20Dispatcher { contract_address: staking_token_address });
        self.reward_token.write(IERC20Dispatcher { contract_address: reward_token_address });
 
        self.owner.write(get_caller_address());
    }
 
    #[abi(embed_v0)]
    impl StakingContract of super::IStakingContract<ContractState> {
        fn set_reward_duration(ref self: ContractState, duration: u256) {
            self.only_owner();
 
            assert(duration > 0, super::Errors::NULL_DURATION);
 
            assert(
                self.finish_at.read() < get_block_timestamp().into(),
                super::Errors::UNFINISHED_DURATION,
            );
 
            self.duration.write(duration);
        }
 
        fn set_reward_amount(ref self: ContractState, amount: u256) {
            self.only_owner();
            self.update_rewards(Zero::zero());
 
            assert(amount > 0, super::Errors::NULL_REWARDS);
            assert(self.duration.read() > 0, super::Errors::NULL_DURATION);
 
            let block_timestamp: u256 = get_block_timestamp().into();
 
            let rate = if self.finish_at.read() < block_timestamp {
                amount / self.duration.read()
            } else {
                let remaining_rewards = self.reward_rate.read()
                    * (self.finish_at.read() - block_timestamp);
                (remaining_rewards + amount) / self.duration.read()
            };
 
            assert(
                self.reward_token.read().balance_of(get_contract_address()) >= rate
                    * self.duration.read(),
                super::Errors::NOT_ENOUGH_REWARDS,
            );
 
            self.reward_rate.write(rate);
 
            self.finish_at.write(block_timestamp + self.duration.read());
            self.last_updated_at.write(block_timestamp);
 
            self.total_distributed_rewards.write(0);
        }
 
        fn stake(ref self: ContractState, amount: u256) {
            assert(amount > 0, super::Errors::NULL_AMOUNT);
 
            let user = get_caller_address();
            self.update_rewards(user);
 
            self.balance_of.write(user, self.balance_of.read(user) + amount);
            self.total_supply.write(self.total_supply.read() + amount);
            self.staking_token.read().transfer_from(user, get_contract_address(), amount);
 
            self.emit(Deposit { user, amount });
        }
 
        fn withdraw(ref self: ContractState, amount: u256) {
            assert(amount > 0, super::Errors::NULL_AMOUNT);
 
            let user = get_caller_address();
 
            assert(
                self.staking_token.read().balance_of(user) >= amount,
                super::Errors::NOT_ENOUGH_BALANCE,
            );
 
            self.update_rewards(user);
 
            self.balance_of.write(user, self.balance_of.read(user) - amount);
            self.total_supply.write(self.total_supply.read() - amount);
            self.staking_token.read().transfer(user, amount);
 
            self.emit(Withdrawal { user, amount });
        }
 
        fn get_rewards(self: @ContractState, account: ContractAddress) -> u256 {
            self.unclaimed_rewards.read(account) + self.compute_new_rewards(account)
        }
 
        fn claim_rewards(ref self: ContractState) {
            let user = get_caller_address();
            self.update_rewards(user);
 
            let rewards = self.unclaimed_rewards.read(user);
 
            if rewards > 0 {
                self.unclaimed_rewards.write(user, 0);
                self.reward_token.read().transfer(user, rewards);
            }
        }
    }
 
    #[generate_trait]
    impl PrivateFunctions of PrivateFunctionsTrait {
        fn update_rewards(ref self: ContractState, account: ContractAddress) {
            self
                .current_reward_per_staked_token
                .write(self.compute_current_reward_per_staked_token());
 
            self.last_updated_at.write(self.last_time_applicable());
 
            if account.is_non_zero() {
                self.distribute_user_rewards(account);
 
                self
                    .last_user_reward_per_staked_token
                    .write(account, self.current_reward_per_staked_token.read());
 
                self.send_rewards_finished_event();
            }
        }
 
        fn distribute_user_rewards(ref self: ContractState, account: ContractAddress) {
            let user_rewards = self.get_rewards(account);
            self.unclaimed_rewards.write(account, user_rewards);
 
            self
                .total_distributed_rewards
                .write(self.total_distributed_rewards.read() + user_rewards);
        }
 
        fn send_rewards_finished_event(ref self: ContractState) {
            if self.last_updated_at.read() == self.finish_at.read() {
                let total_rewards = self.reward_rate.read() * self.duration.read();
 
                if total_rewards != 0 && self.total_distributed_rewards.read() == total_rewards {
                    self.emit(RewardsFinished { msg: 'Rewards all distributed' });
                } else {
                    self.emit(RewardsFinished { msg: 'Rewards not active yet' });
                }
            }
        }
 
        fn compute_current_reward_per_staked_token(self: @ContractState) -> u256 {
            if self.total_supply.read() == 0 {
                self.current_reward_per_staked_token.read()
            } else {
                self.current_reward_per_staked_token.read()
                    + self.reward_rate.read()
                        * (self.last_time_applicable() - self.last_updated_at.read())
                        / self.total_supply.read()
            }
        }
 
        fn compute_new_rewards(self: @ContractState, account: ContractAddress) -> u256 {
            self.balance_of.read(account)
                * (self.current_reward_per_staked_token.read()
                    - self.last_user_reward_per_staked_token.read(account))
        }
 
        #[inline(always)]
        fn last_time_applicable(self: @ContractState) -> u256 {
            Self::min(self.finish_at.read(), get_block_timestamp().into())
        }
 
        #[inline(always)]
        fn min(x: u256, y: u256) -> u256 {
            if (x <= y) {
                x
            } else {
                y
            }
        }
 
        fn only_owner(self: @ContractState) {
            let caller = get_caller_address();
            assert(caller == self.owner.read(), super::Errors::NOT_OWNER);
        }
    }
}
}

Introduction to Cairo Academy's AI Agent Examples

Welcome to the Cairo Academy's collection of AI Agent examples, designed for educational exploration of AI concepts within the StarkNet ecosystem. This resource aims to provide developers with accessible examples to learn how to integrate AI functionalities on StarkNet.

Purpose

This chapter introduces the Cairo Academy's AI Agent examples, outlining their purpose, structure, and intended use. These examples serve as practical demonstrations for developers learning how to implement AI agents on a scalable Layer 2 platform.

Cairo Academy: Exploring AI on StarkNet

Cairo Academy is dedicated to providing high-quality educational resources for developers interested in learning Cairo and exploring the integration of AI within the StarkNet ecosystem. We curate and share sample AI agent examples, tutorials, and other learning materials to facilitate the understanding of AI on StarkNet and encourage experimentation.

Important Note: Cairo Academy focuses exclusively on educational resources. The provided AI agent examples are not intended for production use.

Repository Structure Overview

This section briefly describes the organization of the AI agent examples within the repository. Detailed explanations of individual examples will follow in subsequent chapters.

• [Specific Agent Example 1 Name]: [Brief description of the agent's AI concept and functionality.]
• [Specific Agent Example 2 Name]: [Brief description of the agent's AI concept and functionality.]
• [Specific Agent Example 3 Name]: [Brief description of the agent's AI concept and functionality.]
• ... and so on.

Subsequent chapters will delve into each AI agent example, providing detailed explanations, code walkthroughs, and usage demonstrations.

Contributing to Cairo Academy's AI Agent Examples

We encourage contributions to improve the educational value of this repository. If you are interested in contributing, please consider the following guidelines:

• Focus on clarity and educational value, particularly regarding AI concepts.
• Provide detailed comments and explanations within the code, especially for AI-related logic.
• Ensure that any new AI agent examples or modifications align with the educational goals of Cairo Academy, emphasizing the integration of AI on StarkNet.
• Suggestions for improvements to existing examples are also welcome, especially regarding the clarity of AI implementation.

By contributing, you help enhance the learning experience for others and contribute to the growth of the AI-focused StarkNet community.

Introduction to Cairo Academy Dojo: Gaming Examples

Welcome to the Cairo Academy Dojo Gaming Templates, a collection of gaming examples built with the Dojo engine. This chapter introduces the purpose and structure of this resource, designed to help developers learn game development on StarkNet.

Purpose and Educational Goals

The Cairo Academy Dojo Gaming aims to:

• Provide Practical Gaming Examples: Offer a curated set of gaming projects built with dojo engine, showcasing various game mechanics and patterns.
• Facilitate Learning by Doing: Enable developers to learn game development on StarkNet through hands-on experience and code exploration.
• Demonstrate Dojo and StarkNet Gaming Capabilities: Showcase the power and flexibility of Dojo and StarkNet for building decentralized games.
• Inspire Game Development Innovation: Encourage developers to explore new game concepts and contribute to the growing StarkNet gaming ecosystem.

Cairo Academy Dojo: Focus on Gaming

The Cairo Academy Dojo is specifically designed to provide educational resources for game development on StarkNet. It complements other Cairo Academy resources by focusing on the unique challenges and opportunities of building decentralized games.

Important Note: The gaming examples in this chapter are primarily for educational purposes and may not be optimized for production deployment.

Repository Structure: Gaming Examples

This section provides an overview of the gaming examples contained within the Dojo. Detailed explanations and code walkthroughs will follow in subsequent chapters.

• simple_dice/: A basic dice game demonstrating random number generation and simple game logic.
• tic_tac_toe/: An implementation of the classic Tic-Tac-Toe game, showcasing turn-based gameplay.
• onchain_battles/: A more complex example demonstrating on-chain battles and entity management.
• [Other Gaming Examples]: As the Dojo expands, additional gaming examples will be added to cover a wider range of game mechanics and concepts.

Each gaming example includes well-documented Cairo code, clear explanations, and instructions for running and interacting with the game.

Disclaimer: Educational Gaming Examples

The gaming examples in the Cairo Academy Dojo are provided for educational purposes only. They are not intended for production deployment and may not be optimized for security or performance. Use them at your own risk. Cairo Academy is not responsible for any issues arising from the use of these gaming examples.

This disclaimer emphasizes the educational nature of the gaming examples and encourages responsible use for learning purposes.

Contributing to the Cairo Academy Dojo

We encourage contributions to the Cairo Academy Dojo to enhance its educational value and expand the gaming resources available to the StarkNet community. If you are interested in contributing:

• Ensure that your contributions are clear, well-documented, and aligned with the educational goals of the Dojo.
• Focus on providing practical gaming examples that effectively illustrate game development concepts on StarkNet.
• Provide comprehensive comments and explanations to facilitate understanding.
• Suggestions for improvements to existing gaming examples are also highly welcome.

By contributing, you play a vital role in enriching the learning experience for others and supporting the growth of the StarkNet gaming ecosystem.

Introduction to Cairo Academy's Sample Cairo Programs

Welcome to the Cairo Academy's collection of sample Cairo programs. This chapter introduces the repository and its purpose as an educational resource for learning the Cairo programming language.

Purpose and Educational Goals

This repository serves as a practical learning tool for developers seeking to understand Cairo's core concepts and functionalities. Its primary goals are:

• Educational Resource: To provide a curated set of Cairo programs that illustrate fundamental concepts and programming patterns.
• Facilitated Learning: To offer hands-on examples for developers new to Cairo, fostering learning through practical application.
• Demonstration of Cairo Capabilities: To showcase various aspects of the Cairo language, including arithmetic, logic, memory management, and proof generation.

Cairo Academy's Educational Focus

Cairo Academy is dedicated to providing high-quality educational materials for developers interested in learning Cairo. This repository complements theoretical resources by offering concrete code examples that demonstrate key concepts.

Important Note: The programs within this repository are primarily designed for educational purposes and may not be optimized for production deployment.

Repository Structure: An Overview

This section briefly outlines the organization of the sample Cairo programs within the repository. Detailed explanations of individual programs will follow in subsequent chapters.

• basic_arithmetic/: Examples demonstrating fundamental arithmetic operations in Cairo.
• logic_operations/: Illustrations of logical operations and control flow constructs.
• memory_management/: Showcases of memory manipulation techniques in Cairo.
• proof_generation/: Examples of generating proofs using the Cairo language.
• [Other Relevant Folders]: As the repository evolves, additional folders will be added to cover a wider range of Cairo concepts.

Each folder contains well-documented Cairo programs with clear explanations and comments, making them accessible for learning.

Disclaimer: For Educational Use Only

The Cairo programs presented in this repository are provided exclusively for educational purposes. They are not intended for production deployment and may not be optimized for security or performance. Use them at your own risk. Cairo Academy is not responsible for any issues arising from the use of these programs.

This disclaimer emphasizes the educational nature of these programs and encourages responsible use for learning purposes.

Contributing to Cairo Academy

We encourage contributions to this repository to enhance its educational value and expand the resources available to the Cairo community. If you are interested in contributing:

• Ensure that your contributions are clear, well-documented, and aligned with the educational objectives of Cairo Academy.
• Focus on providing practical examples that effectively illustrate Cairo concepts.
• Provide comprehensive comments and explanations to facilitate understanding.
• Suggestions for improvements to existing examples are also highly welcome.

By contributing, you play a vital role in enriching the learning experience for others and supporting the growth of the Cairo ecosystem.

Cairo Academy: Frontend Templates for StarkNet Applications

Welcome to the Cairo Academy's collection of frontend templates. This resource provides ready-to-use templates designed to accelerate the development of web applications that interact with StarkNet smart contracts.

Purpose and Goals

This repository aims to:

• Facilitate Rapid Development: Offer pre-built frontend templates to streamline the creation of user interfaces for StarkNet applications.
• Encourage UI Innovation: Serve as a platform for developers to explore and contribute new UI patterns and designs tailored for decentralized experiences.
• Showcase Modern Web Technologies: Utilize popular frontend frameworks such as React, Vue, Next.js, and Svelte to demonstrate best practices and modern development techniques.
• Simplify StarkNet Integration: Provide seamless integration with StarkNet through libraries like StarkNet.js, enabling developers to easily connect their frontends to the StarkNet network.

Key Features

• Ready-to-Use Templates: Quickly start building your StarkNet application with pre-configured templates.
• Framework Variety: Support for multiple popular frontend frameworks, allowing developers to choose their preferred technology.
• StarkNet.js Integration: Built-in integration with StarkNet.js for easy interaction with StarkNet contracts.
• Educational Resource: Each template serves as a practical example of how to build a frontend for StarkNet, with clear code and documentation.

Intended Audience

This repository is intended for:

• Developers who are new to StarkNet and want to quickly build a frontend for their applications.
• Experienced developers who want to explore new UI patterns and designs for decentralized applications.
• Anyone interested in learning how to integrate StarkNet with modern frontend frameworks.

Contributing

We encourage contributions to this repository. If you have a new template, a UI pattern, or an improvement to an existing template, please feel free to contribute. By contributing, you help grow the StarkNet ecosystem and provide valuable resources for other developers.

Contributors

We are grateful to the following contributors for improving and expanding Cairo Academy.

Faith M. Roberts	Mayowa Obisesan	Daniel Nwachukwu	Kazeem Hakeem	Hakeem Husseni
Abdulyekeen Lukman	Okeke Chinedu Emmanuel	Yunus Abdulmajid	Mary Wangui	Nathaniel Nanle
Pedro Coelho	Tosin Akinbowa	Emmanuel Okeke

Contributing

We welcome contributions from the community! If you have ideas for new features, templates, or improvements, please submit a pull request or open an issue. Visit the github organization here

Join the Community

Connect with us on our community forum to stay up-to-date on the latest developments and collaborate with other Cairo developers. Telegram.

Thank you for being part of the Cairo Academy journey!