14.11.2024

Lição 025: Funções Receive em Solidity

Nesta lição, vamos explorar as funções receive em Solidity, uma linguagem de programação projetada para escrever contratos inteligentes na blockchain Ethereum. As funções receive são um tipo especial de função que permite que contratos recebam Ether. Compreender como elas funcionam e quando usá-las é crucial para qualquer desenvolvedor Solidity.

O que é uma Função Receive?

Em Solidity, a função receive() é uma função padrão que é executada quando um contrato recebe Ether. Ela é especificamente projetada para lidar com transações de Ether sem dados adicionais. Essa função é essencial quando você deseja que seu contrato aceite pagamentos diretamente.

A função receive() é definida da seguinte forma:

receive() external payable {}

Características da Função Receive

• Visibilidade: A função receive deve ser marcada como external.
• Payable: Ela deve ser marcada como payable para permitir que o contrato aceite Ether.
• Sem parâmetros: A função não aceita parâmetros e não retorna valores.
• Fallback: Se um contrato possui tanto uma função receive() quanto uma função fallback(), a função receive() é chamada quando o Ether é enviado sem dados, enquanto a função fallback() é chamada para chamadas com dados ou se a função receive() não existir.

Exemplo de um Contrato Simples com uma Função Receive

Vamos criar um contrato simples que aceita Ether e armazena o saldo do remetente.

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

contract SimpleWallet {
    // Mapeamento para acompanhar saldos de Ether de cada endereço
    mapping(address => uint256) public balances;

    // Evento emitido quando Ether é recebido
    event Received(address indexed sender, uint256 amount);

    // Função receive para lidar com Ether recebido
    receive() external payable {
        balances[msg.sender] += msg.value; // Atualiza o saldo
        emit Received(msg.sender, msg.value); // Emite o evento
    }

    // Função para retirar Ether do contrato
    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Saldo insuficiente");

        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount); // Envia Ether
    }
}

Explicação do Código

1. Mapeamento para Saldos: Usamos um mapeamento para acompanhar o saldo de cada endereço. Isso permite que os usuários vejam quanto Ether depositaram no contrato.

2. Declaração de Evento: Um evento Received é emitido toda vez que o contrato recebe Ether, o que ajuda a rastrear transações recebidas.

3. Função Receive: A função receive atualiza o saldo do remetente e emite um evento. O valor do Ether enviado está automaticamente disponível em msg.value.

4. Função Withdraw: Uma função que permite aos usuários retirar seu saldo de Ether do contrato. Ela garante que o usuário tenha saldo suficiente antes de prosseguir com a retirada.

Testando o Contrato

Você pode implantar este contrato e interagir com ele através de ferramentas como Remix ou Truffle. Veja como testá-lo:

1. Implemente o contrato SimpleWallet.
2. Envie Ether para o contrato chamando a função send. A função receive() será acionada, e o saldo do remetente será atualizado.
3. Verifique o saldo do remetente usando o mapeamento balances.
4. Chame a função withdraw para retirar o Ether depositado.

Conclusão

Nesta lição, discutimos as funções receive em Solidity e vimos como elas permitem que contratos aceitem Ether facilmente. Também implementamos um contrato de carteira simples que ilustra a funcionalidade das funções receive. Compreender como trabalhar com funções receive é uma habilidade essencial para desenvolvedores Solidity, especialmente ao construir contratos que lidam com transações monetárias.

Agora você pode usar funções receive em seus próprios contratos para aceitar Ether e gerenciar fundos de forma segura!

Video

Navigation