Events are a way to emit data from a contract. All events must be defined in the Event enum, which must be annotated with the #[event] attribute. An event is defined as a struct that derives the starknet::Event trait. The fields of that struct correspond to the data that will be emitted. An event can be indexed for easy and fast access when querying the data at a later time by adding a #[key] attribute to a field member.

Here's a simple example of a contract that emits an event each time a counter is incremented by the increment function:

pub trait IEventCounter<TContractState> {
    fn increment(ref self: TContractState, amount: u128);

pub mod EventCounter {
    use starknet::{get_caller_address, ContractAddress};

    struct Storage {
        // Counter value
        counter: u128,

    #[derive(Copy, Drop, Debug, PartialEq, starknet::Event)]
    // The event enum must be annotated with the `#[event]` attribute.
    // It must also derive at least the `Drop` and `starknet::Event` traits.
    pub enum Event {
        CounterIncreased: CounterIncreased,
        UserIncreaseCounter: UserIncreaseCounter

    // By deriving the `starknet::Event` trait, we indicate to the compiler that
    // this struct will be used when emitting events.
    #[derive(Copy, Drop, Debug, PartialEq, starknet::Event)]
    pub struct CounterIncreased {
        pub amount: u128

    #[derive(Copy, Drop, Debug, PartialEq, starknet::Event)]
    pub struct UserIncreaseCounter {
        // The `#[key]` attribute indicates that this event will be indexed.
        // You can also use `#[flat]` for nested structs.
        pub user: ContractAddress,
        pub new_value: u128,

    impl EventCounter of super::IEventCounter<ContractState> {
        fn increment(ref self: ContractState, amount: u128) {
            self.counter.write( + amount);
            // Emit event
            self.emit(Event::CounterIncreased(CounterIncreased { amount }));
                        UserIncreaseCounter {
                            user: get_caller_address(), new_value:

mod tests {
    use super::{
            counterContractMemberStateTrait, Event, CounterIncreased, UserIncreaseCounter
        IEventCounterDispatcherTrait, IEventCounterDispatcher
    use starknet::{
        ContractAddress, contract_address_const, SyscallResultTrait, syscalls::deploy_syscall
    use starknet::testing::{set_contract_address, set_account_contract_address};

    fn test_increment_events() {
        let (contract_address, _) = deploy_syscall(
            EventCounter::TEST_CLASS_HASH.try_into().unwrap(), 0, array![].span(), false
        let mut contract = IEventCounterDispatcher { contract_address };
        let state = EventCounter::contract_state_for_testing();

        let amount = 10;
        let caller = contract_address_const::<'caller'>();

        // fake caller
        // set back to the contract for reading state
        assert_eq!(, amount);

        // Notice the order: the first event emitted is the first to be popped.
            Option::Some(Event::CounterIncreased(CounterIncreased { amount }))
                Event::UserIncreaseCounter(UserIncreaseCounter { user: caller, new_value: amount })
Last change: 2024-06-09, commit: 3fbfb60