26.11.2024

Lição: 142: Construindo uma Aplicação DeFi Simples

Nesta aula, vamos percorrer o processo de construção de uma simples aplicação de finanças descentralizadas (DeFi) utilizando Solidity. Vamos criar um contrato inteligente para uma plataforma básica de empréstimos descentralizados, onde os usuários podem emprestar e tomar emprestado tokens. Este contrato permitirá que os usuários depositem, retirem, tomem emprestado e reembolsem tokens.

Pré-requisitos

1. Compreensão básica sobre Ethereum e contratos inteligentes.
2. Familiaridade com a linguagem de programação Solidity.
3. Ambiente de desenvolvimento configurado com ferramentas como Hardhat, Truffle ou Remix.

Configurando o Projeto

Primeiro, você precisa configurar um novo projeto. Para este exemplo, usaremos o Hardhat.

mkdir app-defi-simples
cd app-defi-simples
npm init -y
npm install --save-dev hardhat
npx hardhat

Escolha "Criar um projeto de amostra básico" quando solicitado.

Escrevendo o Contrato Inteligente

Agora, vamos escrever o contrato inteligente. Crie um novo arquivo chamado DeFiLending.sol no diretório contracts.

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

contract DeFiLending {
    string public name = "Empréstimo DeFi Simples";
    mapping(address => uint256) public deposits;
    mapping(address => uint256) public loans;

    // O usuário deposita tokens no contrato
    function deposit() public payable {
        require(msg.value > 0, "Deve depositar mais que 0");
        deposits[msg.sender] += msg.value;
    }

    // O usuário retira tokens do contrato
    function withdraw(uint256 amount) public {
        require(deposits[msg.sender] >= amount, "Saldo insuficiente");

        deposits[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }

    // O usuário toma emprestado tokens do contrato
    function borrow(uint256 amount) public {
        require(deposits[msg.sender] > 0, "Deve ter depósitos para tomar emprestado");
        loans[msg.sender] += amount;
        deposits[msg.sender] -= amount; // Tokens emprestados são deduzidos do depósito
        payable(msg.sender).transfer(amount);
    }

    // O usuário reembolsa tokens emprestados
    function repay() public payable {
        require(msg.value > 0, "Deve reembolsar mais que 0");
        require(loans[msg.sender] >= msg.value, "Reembolsando mais que o emprestado");

        loans[msg.sender] -= msg.value;
        deposits[msg.sender] += msg.value; // O reembolso aumenta o depósito
    }

    // Obtém o saldo de depósito do usuário
    function getDepositBalance() public view returns (uint256) {
        return deposits[msg.sender];
    }

    // Obtém o saldo do empréstimo do usuário
    function getLoanBalance() public view returns (uint256) {
        return loans[msg.sender];
    }
}

Explicação do Contrato

1. Função Deposit: Os usuários podem depositar Ether no contrato, o que aumenta o saldo de depósito deles.

2. Função Withdraw: Os usuários podem retirar seu Ether depositado, desde que tenham saldo suficiente.

3. Função Borrow: Os usuários podem tomar emprestado Ether contra seu saldo depositado. Quando tomam emprestado, o valor é deduzido de seu depósito.

4. Função Repay: Isso permite que os usuários reembolsem o Ether emprestado. O valor reembolsado aumenta o saldo de depósito deles.

5. Funções Get Deposit e Loan Balances: Essas funções permitem que os usuários verifiquem seus saldos atuais de depósito e empréstimo.

Implantando o Contrato Inteligente

Vamos implantar o contrato. Crie um novo arquivo no diretório scripts chamado deploy.js.

const hre = require("hardhat");

async function main() {
    const DeFiLending = await hre.ethers.getContractFactory("DeFiLending");
    const defiLending = await DeFiLending.deploy();

    await defiLending.deployed();

    console.log("DeFiLending implantado em:", defiLending.address);
}

main()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });

Agora, você pode implantar o contrato.

npx hardhat run scripts/deploy.js --network <seu_rede>

Interagindo com o Contrato Inteligente

Você pode interagir com o contrato implantado usando qualquer carteira Ethereum que suporte contratos inteligentes, ou pode escrever scripts no diretório scripts para automatizar o processo.

Aqui está um exemplo de como você pode interagir com ele em um script:

async function interact() {
    const [owner] = await hre.ethers.getSigners();
    const defiLendingAddress = "<insira_o_endereço_do_seu_contrato_aqui>";
    const DeFiLending = await hre.ethers.getContractAt("DeFiLending", defiLendingAddress);

    // Depositar 1 ETH
    await DeFiLending.connect(owner).deposit({ value: hre.ethers.utils.parseEther("1") });

    // Checar saldo de depósito
    const depositBalance = await DeFiLending.getDepositBalance();
    console.log("Saldo de depósito:", hre.ethers.utils.formatEther(depositBalance));

    // Tomar emprestado 0.5 ETH
    await DeFiLending.connect(owner).borrow(hre.ethers.utils.parseEther("0.5"));

    // Checar saldo do empréstimo
    const loanBalance = await DeFiLending.getLoanBalance();
    console.log("Saldo do empréstimo:", hre.ethers.utils.formatEther(loanBalance));

    // Reembolsar 0.5 ETH
    await DeFiLending.connect(owner).repay({ value: hre.ethers.utils.parseEther("0.5") });
}

interact();

Conclusão

Nesta aula, criamos uma plataforma simples de empréstimos DeFi usando Solidity. Aprendemos a depositar, retirar, tomar emprestado e reembolsar tokens dentro do nosso contrato inteligente. Isso fornece uma compreensão fundamental sobre a construção de aplicações DeFi, e você pode expandir isso adicionando recursos como taxas de juros, colaterais, ou integrando uma interface usando tecnologias web como React.js.

Bons códigos!

Video

Navigation