02.12.2024

Aula 201: Técnicas de Gas Golf em Solidity

Gas golf é a arte de escrever contratos inteligentes que consomem pouco gás em Solidity. A rede Ethereum exige gás para executar o código, e otimizar seu contrato pode economizar dinheiro para os usuários quando eles interagem com ele. Nesta aula, vamos explorar várias técnicas para minimizar o consumo de gás e fornecer exemplos práticos.

Entendendo os Custos de Gás

Gás é uma medida do trabalho computacional necessário para executar operações na Ethereum. Cada operação possui um custo de gás único, e o custo total é determinado pelo número de operações realizadas. Entender esses custos é crucial para escrever contratos inteligentes eficientes.

Custos Comuns de Gás

Aqui estão alguns custos comuns de gás em Solidity:

• Operações de armazenamento: 20.000 de gás para um novo slot de armazenamento e 5.000 de gás para uma atualização.
• Operações de memória: Aumento do uso de memória gera um custo de 3 de gás por palavra.
• Chamadas externas: Chamar uma função em outro contrato custa 700 de gás, mais o custo de gás das operações da função chamada.

Técnicas de Gas Golf

1. Use Curto-Circuito na Lógica Booleana

Ao avaliar condições, você pode utilizar o curto-circuito para reduzir os custos de gás. Por exemplo, em vez de usar várias declarações if, você pode usar um único if com lógica de curto-circuito.

pragma solidity ^0.8.0;

contract GasGolf {
    bool public conditionA;
    bool public conditionB;

    function example(uint256 value) public {
        if (conditionA && (conditionB || value > 10)) {
            // faça algo
        }
    }
}

Aqui, se conditionA for falso, a segunda parte não será avaliada, economizando gás.

2. Use Funções view e pure

Utilizar funções view e pure pode economizar gás quando você não modifica o estado. Marcar as funções corretamente implica que elas não precisarão de gás para certas operações.

pragma solidity ^0.8.0;

contract GasGolf {
    uint256 public storedValue;

    function setValue(uint256 value) public {
        storedValue = value;  // operação de armazenamento
    }

    function getValue() public view returns (uint256) {
        return storedValue; // sem custo de gás para o chamador
    }

    function calculation(uint256 x) public pure returns (uint256) {
        return x * x; // sem custo de gás para mudanças de estado
    }
}

3. Otimize o Acesso ao Armazenamento

Minimize o número de leituras e gravações de armazenamento. Fazer loops para acessar o armazenamento pode ser custoso. Em vez disso, considere agrupar suas operações:

pragma solidity ^0.8.0;

contract GasGolf {
    uint256 public total;

    function batchUpdate(uint256[] memory values) public {
        require(values.length <= 10, "Excede o limite");
        for (uint i = 0; i < values.length; i++) {
            total += values[i]; // menos gravações de armazenamento
        }
    }
}

4. Use Variáveis constant ou immutable

Use constant para constantes em tempo de compilação e immutable para valores definidos no construtor. Isso pode economizar gás em comparação com variáveis de estado regulares.

pragma solidity ^0.8.0;

contract GasGolf {
    uint256 public constant MAX_LIMIT = 100; // sem custo de armazenamento
    uint256 public immutable creationTime;

    constructor() {
        creationTime = block.timestamp; // definido uma única vez na implantação
    }
}

5. Otimize o Armazenamento de Arrays

Armazene tipos de dados menores em arrays para economizar espaço. Por exemplo, use uint8 em vez de uint256 quando possível.

pragma solidity ^0.8.0;

contract GasGolf {
    uint8[] public data; // custo de armazenamento reduzido

    function addData(uint8 value) public {
        data.push(value);
    }

    function getData(uint index) public view returns (uint8) {
        return data[index]; // leitura eficiente
    }
}

6. Evite Tipos de Dados Dinâmicos Sempre que Possível

Os tipos de dados dinâmicos (como bytes e string) são mais intensivos em gás. Se puder, use tipos de dados de tamanho fixo.

pragma solidity ^0.8.0;

contract GasGolf {
    uint256[5] public data; // tamanho fixo

    function setData(uint256 index, uint256 value) public {
        require(index < 5, "Índice fora dos limites");
        data[index] = value; // menos gás do que arrays dinâmicos
    }
}

Conclusão

O gas golfing em Solidity é essencial para criar contratos inteligentes eficientes e econômicos. Ao entender os custos de gás e implementar as técnicas discutidas nesta aula, você pode reduzir significativamente o consumo de gás dos seus contratos inteligentes. Como os custos de gás são dinâmicos e estão sujeitos a mudanças, também é fundamental se manter atualizado com as últimas otimizações e melhores práticas em Solidity. Boa codificação!

Video

Navigation