Modifiers é Events

Modificadores e eventos são funcionalidades essenciais em Solidity que aumentam a modularidade, segurança e interatividade dos contratos inteligentes. Modificadores permitem adicionar verificações a funções, garantindo que certas condições sejam atendidas antes da execução, enquanto eventos registram informações em logs imutáveis na blockchain, permitindo que interfaces externas, como dApps, sejam notificadas sobre ações ou mudanças de estado. Juntos, eles facilitam a escrita de contratos inteligentes mais eficientes, seguros e transparentes.

Modifiers

Os modificadores (modifiers) em Solidity são uma maneira poderosa de alterar o comportamento das funções em um contrato inteligente. Eles permitem adicionar verificações prévias, validações e outras lógicas comuns de forma reutilizável, melhorando a legibilidade e a segurança do código.

1. O que são Modificadores

Modificadores são blocos de código que podem ser aplicados a funções para executar lógica adicional antes ou depois da função ser chamada, ou até mesmo impedir a execução da função, se certas condições não forem atendidas.

2. Sintaxe de Modificadores

A sintaxe básica de um modificador inclui a declaração do modificador, o código que ele deve executar, e uma chamada a _ (underscore), que representa a execução da função original.

pragma solidity ^0.8.0;

contract ExemploModificadores {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    // Declarando um modificador
    modifier somenteProprietario() {
        require(msg.sender == owner, "Apenas o proprietario pode chamar esta funcao");
        _;
    }

    // Usando o modificador em uma função
    function funcaoRestrita() public somenteProprietario {
        // Código da função
    }
}

No exemplo acima, o modificador somenteProprietario verifica se o chamador da função é o proprietário do contrato antes de permitir a execução da função funcaoRestrita.

3. Usos Comuns de Modificadores

Verificações de Propriedade

Modificadores são frequentemente usados para restringir o acesso a certas funções para o proprietário do contrato ou para usuários específicos.

modifier somenteProprietario() {
    require(msg.sender == owner, "Apenas o proprietario pode chamar esta funcao");
    _;
}

Verificações de Estado

Você pode usar modificadores para garantir que uma função só seja executada em um estado específico do contrato.

enum Estado { Inativo, Ativo }
Estado public estadoAtual = Estado.Inativo;

modifier somenteQuandoAtivo() {
    require(estadoAtual == Estado.Ativo, "Contrato nao esta ativo");
    _;
}

function ativarContrato() public somenteProprietario {
    estadoAtual = Estado.Ativo;
}

function funcaoAtiva() public somenteQuandoAtivo {
    // Código da função
}

Limitação de Chamadas

Modificadores podem ser usados para limitar a frequência com que uma função pode ser chamada.

uint public ultimaChamada;

modifier intervaloMinimo(uint _tempo) {
    require(block.timestamp >= ultimaChamada + _tempo, "Intervalo minimo nao cumprido");
    _;
    ultimaChamada = block.timestamp;
}

function funcaoLimitada() public intervaloMinimo(1 minutes) {
    // Código da função
}

4. Modificadores com Parâmetros

Modificadores podem aceitar parâmetros, permitindo criar verificações dinâmicas e reutilizáveis.

modifier somenteValorMinimo(uint _valorMinimo) {
    require(msg.value >= _valorMinimo, "Valor enviado e menor que o minimo exigido");
    _;
}

function funcaoPagavel() public payable somenteValorMinimo(1 ether) {
    // Código da função
}

5. Combinando Modificadores

Você pode combinar múltiplos modificadores em uma única função para realizar várias verificações.

modifier somenteQuandoAtivo() {
    require(estadoAtual == Estado.Ativo, "Contrato nao esta ativo");
    _;
}

modifier somenteValorMinimo(uint _valorMinimo) {
    require(msg.value >= _valorMinimo, "Valor enviado e menor que o minimo exigido");
    _;
}

function funcaoCombinada() public payable somenteQuandoAtivo somenteValorMinimo(1 ether) {
    // Código da função
}

6. Exemplo Completo

Aqui está um exemplo completo que combina várias práticas mencionadas:

pragma solidity ^0.8.0;

contract ExemploModificadores {
    address public owner;
    enum Estado { Inativo, Ativo }
    Estado public estadoAtual = Estado.Inativo;
    uint public ultimaChamada;

    constructor() {
        owner = msg.sender;
    }

    modifier somenteProprietario() {
        require(msg.sender == owner, "Apenas o proprietario pode chamar esta funcao");
        _;
    }

    modifier somenteQuandoAtivo() {
        require(estadoAtual == Estado.Ativo, "Contrato nao esta ativo");
        _;
    }

    modifier intervaloMinimo(uint _tempo) {
        require(block.timestamp >= ultimaChamada + _tempo, "Intervalo minimo nao cumprido");
        _;
        ultimaChamada = block.timestamp;
    }

    modifier somenteValorMinimo(uint _valorMinimo) {
        require(msg.value >= _valorMinimo, "Valor enviado e menor que o minimo exigido");
        _;
    }

    function ativarContrato() public somenteProprietario {
        estadoAtual = Estado.Ativo;
    }

    function funcaoRestrita() public somenteProprietario somenteQuandoAtivo intervaloMinimo(1 minutes) {
        // Código da função
    }

    function funcaoPagavel() public payable somenteQuandoAtivo somenteValorMinimo(1 ether) {
        // Código da função
    }
}

7. Melhores Práticas para utilização de Modificadores

Modificadores em Solidity são ferramentas poderosas que permitem adicionar funcionalidades transversais ao seu código de contrato de forma modular e reutilizável. Ao utilizá-los de forma eficaz, você pode melhorar a organização, legibilidade e segurança do seu código.

Quando Utilizar Modificadores:

Para verificar pré-condições: Antes de executar uma função, utilize um modificador para verificar se as condições necessárias estão atendidas, como saldo suficiente ou permissões adequadas.
Para executar ações repetitivas: Agrupe tarefas comuns, como registro de eventos ou verificações de autenticação, em um modificador para evitar código duplicado.
Para restringir o acesso a funções: Utilize modificadores para controlar quem pode chamar determinadas funções, como onlyOwner para restringir o acesso a funções administrativas.

Utilize modificadores em funções que realizam operações críticas ou sensíveis, como transferências de fundos, alterações de estado importantes ou atualizações de dados chave.

Exemplo:

modifier intervaloMinimo(uint _tempo) {
    require(block.timestamp >= ultimaChamada + _tempo, "Intervalo mínimo não cumprido");
    _;
    ultimaChamada = block.timestamp;
}

modifier somenteQuandoAtivo() {
    require(estadoAtual == Estado.Ativo, "Contrato não está ativo");
    _;
}

modifier onlyOwner() {
    require(msg.sender == owner, "Apenas o proprietário pode executar esta função");
    _;
}

function atualizarTaxa(uint _novaTaxa) public onlyOwner {
    taxa = _novaTaxa;
}

function transferirFundos(address _destinatario, uint _quantidade) public onlyOwner {
    require(saldo >= _quantidade, "Saldo insuficiente");
    saldo -= _quantidade;
    _destinatario.transfer(_quantidade);
}

Onde Utilizar Modificadores:

No início de uma função: Utilize modifier antes da definição da função para aplicar o modificador a toda a função.
Antes de blocos de código: Utilize modifier antes de um bloco de código dentro de uma função para aplicar o modificador apenas a essa parte específica.
Em bibliotecas: Crie modificadores reutilizáveis em bibliotecas para serem utilizados em diferentes contratos.

Melhores Práticas para Modificadores:

Siga o padrão Checks-Effects-Interactions: Verifique as condições (Checks), realize os efeitos (Effects) e execute as interações (Interactions) em uma ordem específica para garantir a previsibilidade e segurança do código.
Utilize modificadores somente para verificações: Evite modificar o estado do contrato dentro de um modificador, pois isso pode levar a erros e dificultar a compreensão do código.
Combine modificadores com require: Utilize require dentro de um modificador para lançar uma exceção se as condições não forem atendidas, garantindo que o código principal da função não seja executado.
Utilize modificadores de forma composível: Combine modificadores para criar funcionalidades mais complexas, reutilizando lógica comum.
Documente seus modificadores: Explique claramente o propósito do modificador, as condições verificadas e como ele deve ser utilizado.
- Exemplos:
Verificar saldo antes de transferir tokens:

modifier onlyEnoughBalance(uint256 _amount) {
    require(msg.value >= _amount, "Insufficient balance");
    _;
}

function transferTokens(address _to, uint256 _amount) public onlyEnoughBalance(_amount) {
    // Transfer tokens to _to
}

Restringir acesso a funções administrativas:

modifier onlyOwner() {
    require(msg.sender == owner, "Only owner can call this function");
    _;
}

function setFee(uint256 _newFee) public onlyOwner {
    fee = _newFee;
}

Lembre-se:

Modificadores são ferramentas poderosas para organizar e modularizar seu código, mas devem ser usados com cuidado para evitar erros e manter a clareza do código.
Siga as melhores práticas descritas aqui para garantir que seus modificadores sejam utilizados de forma eficiente, segura e eficaz.
Sempre consulte a documentação oficial e tutoriais para se aprofundar no uso de modificadores em Solidity.

Conclusão

Os modificadores em Solidity são ferramentas essenciais para escrever contratos inteligentes seguros, eficientes e fáceis de manter. Seguindo estas melhores práticas, você pode garantir que os modificadores sejam utilizados de forma eficaz para adicionar verificações, restrições e lógica reutilizável às suas funções. Isso não só melhora a segurança e a robustez do seu contrato, mas também torna o código mais legível e organizado.

Events

Eventos (Events) em Solidity são uma maneira eficiente de registrar informações em logs na blockchain. Eles permitem que contratos inteligentes comuniquem informações para interfaces externas, como dApps, de forma eficiente. Além disso, eventos são uma ferramenta poderosa para depuração e auditoria, uma vez que os logs são imutáveis e armazenados na blockchain.

1. O que são Eventos

Eventos são semelhantes a funções, mas em vez de executar código, eles registram dados em logs específicos da blockchain. Esses logs podem ser lidos por interfaces fora da blockchain, como aplicativos descentralizados (dApps).

2. Declaração de Eventos

Para declarar um evento, você usa a palavra-chave event, seguida pelo nome do evento e pelos parâmetros que deseja registrar.

pragma solidity ^0.8.0;

contract ExemploEventos {
    // Declarando um evento
    event Transferencia(address indexed de, address indexed para, uint valor);
}

3. Emitindo Eventos

Para emitir um evento, você usa a palavra-chave emit seguida pelo nome do evento e os valores dos parâmetros.

pragma solidity ^0.8.0;

contract ExemploEventos {
    event Transferencia(address indexed de, address indexed para, uint valor);

    function transferir(address _para, uint _valor) public {
        // Lógica de transferência (omitida)
        
        // Emitindo o evento
        emit Transferencia(msg.sender, _para, _valor);
    }
}

4. Indexed Parameters

Os parâmetros de um evento podem ser marcados como indexed, permitindo buscas eficientes nos logs. Você pode indexar até três parâmetros por evento.

pragma solidity ^0.8.0;

contract ExemploEventos {
    event Transferencia(address indexed de, address indexed para, uint valor);

    function transferir(address _para, uint _valor) public {
        // Lógica de transferência (omitida)

        // Emitindo o evento com parâmetros indexados
        emit Transferencia(msg.sender, _para, _valor);
    }
}

5. Utilização Prática de Eventos

Registro de Transações

Eventos são frequentemente usados para registrar transações financeiras.

pragma solidity ^0.8.0;

contract MyWallet {
    event Transferencia(address indexed de, address indexed para, uint valor);

    mapping(address => uint) public saldos;

    function depositar() public payable {
        saldos[msg.sender] += msg.value;
        emit Transferencia(address(0), msg.sender, msg.value);
    }

    function sacar(uint _valor) public {
        require(saldos[msg.sender] >= _valor, "Saldo insuficiente");
        saldos[msg.sender] -= _valor;
        payable(msg.sender).transfer(_valor);
        emit Transferencia(msg.sender, address(0), _valor);
    }
}

Monitoramento de Eventos

Aplicações externas podem monitorar esses eventos usando bibliotecas como Web3.js ou Ethers.js para interagir com a blockchain.

// Exemplo usando Web3.js //alterar codigo para ethers.js 
const Web3 = require('web3');
const web3 = new Web3('ws://localhost:8545');

const contrato = new web3.eth.Contract(abi, enderecoContrato);

contrato.events.Transferencia({
    filter: {},
    fromBlock: 'latest'
}, function(error, event) {
    if (!error) {
        console.log(event);
    }
});

6. Eventos como Ferramenta de Depuração

Emitir eventos pode ser uma maneira útil de depurar contratos inteligentes, permitindo que você registre informações sobre o estado interno do contrato.

pragma solidity ^0.8.0;

contract ExemploDepuracao {
    event Log(address remetente, string mensagem, uint timestamp);

    function acao() public {
        emit Log(msg.sender, "Acao executada", block.timestamp);
    }
}

7. Boas Práticas com Eventos

Seguir boas práticas ao utilizar eventos em Solidity pode ajudar a garantir que seus contratos inteligentes sejam mais eficientes, seguros e fáceis de manter. Eventos são uma ferramenta valiosa para registro e monitoramento, mas devem ser usados de forma criteriosa e estratégica para maximizar seus benefícios e minimizar custos. Para garantir que os eventos sejam usados de forma eficaz, segura e econômica, sugerimos algumas práticas:

1. Emita Eventos para Ações Importantes

Utilize eventos para registrar ações significativas no contrato inteligente, como transferências de tokens, mudanças de estado ou atualizações de dados críticos. Isso permite que os usuários e desenvolvedores monitorem e auditem facilmente essas ações.

event Transferencia(address indexed de, address indexed para, uint valor);
event EstadoAtualizado(uint indexed novoEstado);

2. Use Parâmetros Indexados

Parâmetros indexados permitem buscas eficientes nos logs da blockchain. Você pode indexar até três parâmetros por evento. Utilize parâmetros indexados para campos que provavelmente serão usados como critérios de busca.

event Transferencia(address indexed de, address indexed para, uint valor);

3. Economia de Gás

Embora emitir eventos seja mais barato do que armazenar dados permanentemente, ainda há um custo de gás associado. Emita eventos apenas quando necessário e evite emitir eventos redundantes ou excessivos.

function transferir(address _para, uint _valor) public {
    // Lógica de transferência
    emit Transferencia(msg.sender, _para, _valor);
}

4. Design de Eventos Clareza

Defina eventos com nomes claros e parâmetros relevantes. Isso facilita a interpretação dos logs e a integração com interfaces externas.

event Deposito(address indexed de, uint valor);
event Saque(address indexed para, uint valor);

5. Evite Dependência Excessiva de Eventos

Eventos são úteis para registro e monitoramento, mas não devem ser usados como fonte de verdade para dados críticos. Use armazenamento no contrato para dados importantes e utilize eventos apenas para registro e auditoria.

6. Limitações de Eventos

Lembre-se de que eventos não são acessíveis dentro do contrato. Eles são destinados a interfaces externas. Não baseie a lógica interna do contrato na ocorrência de eventos.

7. Segurança e Privacidade

Eventos são públicos e visíveis para todos. Evite registrar informações sensíveis ou privadas em eventos. Se precisar registrar dados sensíveis, considere estratégias de anonimização ou criptografia.

event DadosAtualizados(address indexed usuario, bytes32 dadoHash);

8. Documentação e Comentários

Documente os eventos em seu contrato para que outros desenvolvedores compreendam seu propósito e uso. Inclua comentários sobre o significado de cada parâmetro e a razão pela qual o evento é emitido.

// Emitido quando um usuário deposita fundos no contrato
event Deposito(address indexed de, uint valor);

// Emitido quando um usuário saca fundos do contrato
event Saque(address indexed para, uint valor);

9. Emitir Eventos no Final da Função

É uma boa prática emitir eventos após a execução da lógica principal da função para garantir que o evento só seja registrado se a operação principal for bem-sucedida.

function transferir(address _para, uint _valor) public {
    // Lógica de transferência
    require(saldo[msg.sender] >= _valor, "Saldo insuficiente");
    saldo[msg.sender] -= _valor;
    saldo[_para] += _valor;

    // Emitindo evento após a lógica principal
    emit Transferencia(msg.sender, _para, _valor);
}

10. Considere Eventos de Depuração

Durante o desenvolvimento e a depuração, eventos podem ser úteis para registrar informações de depuração. Certifique-se de remover ou desativar esses eventos em versões de produção para economizar gás.

event LogDebug(string mensagem, uint timestamp);

function exemploDepuracao() public {
    emit LogDebug("A função foi chamada", block.timestamp);
    // Lógica da função
}

Conclusão

Eventos em Solidity são uma ferramenta essencial para registrar informações e interagir com aplicações externas. Eles melhoram a transparência, facilitam a depuração e permitem a comunicação eficiente com interfaces de usuário. Seguindo as práticas recomendadas e utilizando eventos de forma estratégica, você pode construir contratos inteligentes mais robustos e interativos.

PreviousMaterial Encontro 6