🎡Eventos

Um contrato inteligente do ink! pode definir eventos que podem ser emitidos durante a execução do contrato. A emissão de eventos pode ser usada por ferramentas de terceiros para consultar informações sobre a execução e o estado de um contrato.

Contract execution via transaction

Exemplo​

O exemplo a seguir de um contrato ink! mostra como um evento "Transferred" é definido e emitido no #[ink(constructor)].

#[ink::contract]
mod erc20 {
    /// Defines an event that is emitted
    /// every time value is transferred.
    #[ink(event)]
    pub struct Transferred {
        from: Option<AccountId>,
        to: Option<AccountId>,
        value: Balance,
    }

    #[ink(storage)]
    pub struct Erc20 {
        total_supply: Balance,
        // more fields ...
    }

    impl Erc20 {
        #[ink(constructor)]
        pub fn new(initial_supply: Balance) -> Self {
            let caller = Self::env().caller();
            Self::env().emit_event(Transferred {
                from: None,
                to: Some(caller),
                value: initial_supply,
            });
            Self { total_supply: initial_supply }
        }

        #[ink(message)]
        pub fn total_supply(&self) -> Balance {
            self.total_supply
        }
    }
}

Veja nosso contrato de exemplo ERC20 para um exemplo detalhado que utiliza eventos.

Definição de Evento​

Assim é como uma definição de evento se parece:

#[ink(event)]
pub struct Transferred {
    #[ink(topic)]
    from: Option<AccountId>,

    #[ink(topic)]
    to: Option<AccountId>,

    amount: Balance

}

Adicione a tag de atributo #[ink(topic)] a cada item do seu evento que você deseja que seja indexado. Uma boa regra é se perguntar se alguém pode querer pesquisar por esse tópico. Por esse motivo, o amount no evento exemplar acima não foi tornada indexável - provavelmente haverá muitos eventos diferentes com valores variados.

A assinatura do evento é, por padrão, um dos tópicos do evento, a menos que você anote o evento com #[ink(anonymous)]. Consulte aqui para obter detalhes sobre esse atributo.

Emitting Events in a Constructor​

Em um construtor, os eventos são emitidos através de Self::env().emit_event(). Veja este exemplo:

#[ink(constructor)]
pub fn new(initial_value: Balance) -> Self {
    let caller = Self::env().caller();
    let mut balances = HashMap::new();
    balances.insert(caller, initial_supply);

    Self::env().emit_event(Transferred {
        from: None,
        to: Some(caller),
        amount: initial_supply
    });

    Self { total_supply: initial_supply, balances }
}

Emitindo Eventos a partir de Mensagens​

Em uma mensagem, os eventos são emitidos através de self.env().emit_event():

#[ink(message)]
pub fn transfer(&mut self, to: AccountId, amount: Balance) -> Result {
    let from = self.env().caller();
    // implementation hidden
    self.env().emit_event(Transferred {
        from: Some(from),
        to: Some(to),
        amount
    });
    Ok(())
}