Funções e Modificadores

Nesse artigo iremos abordar sobre as várias formas de trabalhar com funções, modificadores e views no Solidity.

Falaremos sobre function, view, pure e function modifier.

Function (Função)

Uma função pública não pode aceitar certos tipos de dados como entradas ou saídas.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract Function {
    // As funções podem retornar vários valores.
    function returnMany()
        public
        pure
        returns (
            uint,
            bool,
            uint
        )
    {
        return (1, true, 2);
    }

    // Os valores de retorno podem ser nomeados.
    function named()
        public
        pure
        returns (
            uint x,
            bool b,
            uint y
        )
    {
        return (1, true, 2);
    }

    // Os valores de retorno podem ser atribuídos ao seu nome.
    // Nesse caso, a instrução de retorno pode ser omitida.
    function assigned()
        public
        pure
        returns (
            uint x,
            bool b,
            uint y
        )
    {
        x = 1;
        b = true;
        y = 2;
    }

    // Use atribuição de desestruturação ao chamar
    // outra função que retorne vários valores.
    function destructuringAssignments()
        public
        pure
        returns (
            uint,
            bool,
            uint,
            uint,
            uint
        )
    {
        (uint i, bool b, uint j) = returnMany();

        // Os valores podem ficar de fora.
        (uint x, , uint y) = (4, 5, 6);

        return (i, b, j, x, y);
    }

    // Não é possível usar o mapa para entrada ou saída

    // Pode usar array para entrada
    function arrayInput(uint[] memory _arr) public {}

    // Pode usar array para saída
    uint[] public arr;

    function arrayOutput() public view returns (uint[] memory) {
        return arr;
    }
}

View & Pure Function (Funções de Visualização e Funções Puras)

As funções de retorno (getter) podem ser declaradas como view ou pure

• view - quando declarada em uma função, significa que nenhum estado será alterado

• pure - quando declarada em uma função, significa que nenhuma variável de estado será alterada ou lida

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract ViewAndPure {
    uint public x = 1;

    // Define que não irá modificar o estado.
    function addToX(uint y) public view returns (uint) {
        return x + y;
    }

    // Define que não irá modificar ou ler do estado.
    // Útil para funções que realizam operações locais internas.
    function add(uint i, uint j) public pure returns (uint) {
        return i + j;
    }
}

Function Modifier (Modificador de função)

Modificadores são códigos que podem ser executados antes e/ou depois de uma chamada de função.

Modificadores podem ser usados para:

• Acesso restrito
• Validar entradas
• Proteja-se contra o hack de reentrada

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract FunctionModifier {
    // Usaremos essas variáveis para demonstrar como usar modificadores
    address public owner;
    uint public x = 10;
    bool public locked;

    constructor() {
        // Defina o remetente da transação como o proprietário do contrato.
        owner = msg.sender;
    }

    // Modificador para verificar se o chamador é o proprietário do contrato.
    modifier onlyOwner() {
        require(msg.sender == owner, "Não é o proprietário");
        // Underscore é um caractere especial usado apenas dentro
        // de um modificador de função e diz ao Solidity para
        // executar o resto do código.
        _;
    }

    // Modificadores podem receber entradas. 
    // Este modificador verifica se o endereço passado não é o endereço zero.
    modifier validAddress(address _addr) {
        require(_addr != address(0), "Não é um endereço válido");
        _;
    }

    // Função que altera o dono do contrato para o endereço passado por parâmetro
    function changeOwner(address _newOwner) public onlyOwner validAddress(_newOwner) {
        owner = _newOwner;
    }

    // Modificadores podem ser chamados antes e/ou depois de uma função.
    // Este modificador impede que uma função seja chamada enquanto
    // ainda está em execução.
    modifier noReentrancy() {
        require(!locked, "Sem reentrada");

        locked = true;
        _;
        locked = false;
    }

    function decrement(uint i) public noReentrancy {
        x -= i;

        if (i > 1) {
            decrement(i - 1);
        }
    }
}

Testar no Remix