#03 O que é um Smart Contract?

Se você já ouviu falar em Ethereum, provavelmente também já ouviu o termo smart contract (contrato inteligente). Mas afinal, o que isso significa?

Um smart contract é como um programa de computador que vive dentro da blockchain. Ele executa regras pré-definidas, sem precisar de intermediários ou confiança em uma instituição.

Imagine um contrato de aluguel. Normalmente, você precisa de um advogado, imobiliária e cartório para garantir que o contrato seja cumprido.

Com um smart contract, tudo acontece automaticamente:

• Se o pagamento é feito, a chave digital é liberada.

• Se não há pagamento, o acesso é bloqueado.

Tudo isso é validado pela blockchain, sem depender de “pessoas no meio”.

• São escritos em linguagens de programação como Solidity (a mais famosa).

• Depois de criados, são implantados na blockchain Ethereum.

• Uma vez ativos, não podem ser alterados — só executam o que foi programado.

• Eliminam intermediários.

• Garantem confiança entre pessoas que nunca se viram.

• São a base de todo o DeFi (Finanças Descentralizadas), NFTs e até DAOs (organizações autônomas).

Um contrato inteligente pode dizer:

“Se alguém enviar 1 ETH para este endereço, ele recebe automaticamente um token em troca.”

Parece simples, mas isso abre portas para bolsas descentralizadas, empréstimos automáticos e até jogos Web3.

Para criar um contrato que troque ETH por um token, você precisará de dois contratos: um para o token ERC-20 que será distribuído e um segundo que age como uma “máquina de venda” (TokenVendingMachine). Este segundo contrato irá receber o ETH e, em troca, transferir o token para o endereço que enviou o ETH.

Para o token ERC-20, a maneira mais segura e recomendada é usar as bibliotecas da OpenZeppelin, que oferecem implementações auditadas e padronizadas. Você precisará importar a biblioteca para o seu código.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;
import “@openzeppelin/contracts/token/ERC20/ERC20.sol”;
import “@openzeppelin/contracts/access/Ownable.sol”;
contract MyToken is ERC20, Ownable {
    // Define o número de casas decimais do token
    function decimals() public view virtual override returns (uint8) {
        return 18; // Standard for most ERC20s
    }
    constructor() ERC20(”MyToken”, “MTK”) Ownable(msg.sender) {
        // O criador do contrato (deployer) é o dono
        // E recebe o mint inicial de tokens
        _mint(msg.sender, 1000000 * 10 ** decimals());
    }
   // A função de mint pode ser chamada apenas pelo dono
   function mint(address to, uint256 amount) public onlyOwner{
        _mint(to, amount);
    }
}

Este contrato receberá o ETH e, em troca, vai transferir uma quantidade pré-definida do seu token. Ele precisa ter saldo de tokens (balance) para poder enviar aos compradores.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;
import “./MyToken.sol”;
contract TokenVendingMachine {
    MyToken public myToken;
    address private immutable i_owner;
    error NotOwner(string message);
    // 1 ETH = 10 tokens
    uint256 public constant ETH_TO_TOKEN_RATE = 10;
    event TokensSwapped(address indexed buyer,
                        uint256 ethAmount,
                        uint256 tokenAmount);
    modifier onlyOwner() {
        if (msg.sender != i_owner) revert
              NotOwner(”Apenas o dono pode retirrar o ETH.”);
        _;
    }
    constructor(address _tokenAddress) {
        myToken = MyToken(_tokenAddress);
        i_owner = msg.sender;
    }
    // A função `receive` é executada quando o contrato
    // recebe ETH sem dados.  Deve ser `external` e `payable`.
    receive() external payable {
        // Reverte a transação se valor for diferente de 1 ETH
        require(msg.value == 1 ether,
                “Exatamente 1 ETH deve ser enviado.”);
        uint256 tokenAmount = (msg.value * ETH_TO_TOKEN_RATE) / 1 ether;
        // Verifica se o contrato tem tokens suficientes
        require(myToken.balanceOf(address(this)) >= tokenAmount,
                “O contrato nao tem tokens suficientes”);
        // Transfere os tokens para quem enviou o ETH
        myToken.transfer(msg.sender, tokenAmount);
        // Emite um evento para registrar a troca na blockchain
        emit TokensSwapped(msg.sender, msg.value, tokenAmount);
    }
    // Função para transferir os tokes para o ETH recebido.
    function withdrawETH() external onlyOwner {
        payable(msg.sender).transfer(address(this).balance);
    }
    // Função para transferir tokens para este contrato
    function depositTokens(uint256 amount) external {
        // Garante que apenas o dono do token pode depositar
        require(myToken.owner() == msg.sender,
                “Apenas o dono do token pode depositar.”);
        myToken.transferFrom(msg.sender,address(this),amount);
    }
}

1. Implantar MyToken: Use o Remix para implantar o contrato MyToken. O endereço de quem o implantou receberá o fornecimento inicial.

2. Implantar TokenVendingMachine: Implante o TokenVendingMachine passando o endereço do contrato MyToken recém-implantado.

3. Depositar tokens: Chame a função depositTokens() no contrato TokenVendingMachine, usando o endereço que implantou MyToken e uma quantidade de tokens a ser depositada para venda.

4. Troca de ETH por tokens: Qualquer pessoa pode enviar exatamente 1 ETH para o endereço do contrato TokenVendingMachine para receber 10 tokens MTK em troca.

Resumo: Smart contracts são linhas de código que valem como contratos jurídicos na blockchain, só que muito mais rápidos, transparentes e globais. Eles são a base para entender qualquer passo seguinte no mundo Ethereum.