Reading · ETH Beagá · RSS Amplifier

O DeFi (Decentralized Finance) é o ecossistema financeiro do Ethereum — sem bancos, sem intermediários, apenas smart contracts e carteiras digitais.
Nele, qualquer pessoa pode emprestar, tomar emprestado, trocar ou investir em ativos digitais usando apenas a internet.

Tudo gira em torno de contratos inteligentes que:

Guardam e movimentam criptoativos com regras automáticas.
Substituem bancos e instituições.
São auditáveis e imutáveis na blockchain.

Os principais blocos do DeFi:

Lending/Borrowing: empréstimos garantidos (ex: Aave, Compound)
Exchanges: trocas de tokens via AMMs (ex: Uniswap)
Stablecoins: ativos estáveis lastreados em moedas fiduciárias (ex: DAI, USDC)
Staking e Liquidez: recompensas por participar das redes (ex: Lido)

Um dApp (Decentralized Application) é um aplicativo que opera sobre uma blockchain — como a Ethereum — e utiliza smart contracts para executar suas funções de forma autônoma, transparente e sem intermediários.

Diferente de aplicativos tradicionais hospedados em servidores centralizados, os dApps têm seu código e dados distribuídos na rede, garantindo segurança, imutabilidade e resistência à censura.

Normalmente, contam com uma interface web ou mobile, conectada à carteira do usuário (como a MetaMask), permitem interações diretas com os contratos inteligentes, seja para enviar transações, consultar dados ou participar de serviços como DeFi, NFTs e DAOs.

Atenção: Este exemplo é apenas educativo e não está pronto para ser usado fora de uma testnet.

Aqui vai um exemplo simplificado de contrato de empréstimo sem colateral, apenas para fins didáticos:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract SimpleLending {
    mapping(address => uint256) public deposits;
    mapping(address => uint256) public loans;
    uint256 public interestRate = 10; // 10%
    // Depositar ETH no pool
    function deposit() external payable {
        require(msg.value > 0, “Envie algum valor”);
        deposits[msg.sender] += msg.value;
    }
    // Tomar emprestado até 50% do saldo do pool
    function borrow(uint256 amount) external {
        require(amount <= address(this).balance / 2, “Limite excedido”);
        loans[msg.sender] += amount;
        payable(msg.sender).transfer(amount);
    }
    // Quitar o empréstimo com juros
    function repay() external payable {
        uint256 debt = loans[msg.sender] + (loans[msg.sender] * interestRate / 100);
        require(msg.value >= debt, “Valor insuficiente”);
        loans[msg.sender] = 0;
    }
    // Consultar saldo total do pool
    function getPoolBalance() external view returns (uint256) {
        return address(this).balance;
    }
}

O que esse smart contract permite?

Usuários podem depositar ETH.
Outros podem pegar emprestado até metade do total.
Pagamentos retornam com juros fixos.

Crie um arquivo index.html:

<!DOCTYPE html>
<html lang=”pt-BR”>
<head>
  <meta charset=”UTF-8”>
  <title>dApp DeFi - Empréstimo Simples</title>
  <script src=”https://cdn.jsdelivr.net/npm/ethers@6.7.0/dist/ethers.min.js”></script>
  <script src=”app.js” defer></script>
</head>
<body>
  <h1>dApp DeFi - Empréstimo Simples</h1>
  <button onclick=”connectWallet()”>Conectar MetaMask</button>
  <div>
    <input id=”depositValue” type=”number” placeholder=”Valor em ETH”>
    <button onclick=”deposit()”>Depositar</button>
  </div>
  <div>
    <input id=”borrowValue” type=”number” placeholder=”Valor em ETH”>
    <button onclick=”borrow()”>Tomar emprestado</button>
  </div>
  <div>
    <input id=”repayValue” type=”number” placeholder=”Valor em ETH”>
    <button onclick=”repay()”>Quitar empréstimo</button>
  </div>
  <pre id=”log”></pre>
</body>
</html>

E o script app.js:

const contractAddress = “0x1234abcd5678ef90123456789abcdef012345678”;
const abi = [
  “function deposit() payable”,
  “function borrow(uint256 amount)”,
  “function repay() payable”,
  “function getPoolBalance() view returns (uint256)”
];
let signer, contract;
async function connectWallet() {
  await window.ethereum.request({ method: ‘eth_requestAccounts’ });
  const provider = new ethers.BrowserProvider(window.ethereum);
  signer = await provider.getSigner();
  contract = new ethers.Contract(contractAddress, abi, signer);
  log(”Carteira conectada!”);
}
async function deposit() {
  const value = document.getElementById(”depositValue”).value;
  const tx = await contract.deposit({ value: ethers.parseEther(value) });
  await tx.wait();
  log(”Depósito realizado!”);
}
async function borrow() {
  const value = document.getElementById(”borrowValue”).value;
  const tx = await contract.borrow(ethers.parseEther(value));
  await tx.wait();
  log(”Empréstimo recebido!”);
}
async function repay() {
  const value = document.getElementById(”repayValue”).value;
  const tx = await contract.repay({ value: ethers.parseEther(value) });
  await tx.wait();
  log(”Empréstimo quitado!”);
}
function log(msg) {
  document.getElementById(”log”).textContent = msg;
}

Depois de escrever e compilar seu contrato inteligente no Remix, o próximo passo é colocá-lo no ar — e é aqui que entra a MetaMask.

No Remix, abra a aba “Deploy & Run Transactions”, e no campo Environment, selecione “Injected Provider - MetaMask”. Isso faz com que o Remix use a conta conectada na MetaMask para o deploy.
Clique em Deploy, e a MetaMask abrirá uma janela pedindo confirmação.
Após confirmar, o contrato será implantado na blockchain da Sepolia, e você verá o endereço do contrato no painel do Remix.

Copie esse endereço e adicione no seu dApp front-end (por exemplo, em const contractAddress = “0x...”) — é com ele que a interface web vai se comunicar via ethers.js.

Rede: Testnet Sepolia
Carregar a MetaMask com saldo ETH de teste: use um faucet oficial da Sepolia.

Crie um repositório defi-lending-dapp.
Faça upload de index.html e app.js.
Vá em Settings → Pages → Branch: main /(root).
Acesse:

https://<seu-usuario>.github.io/defi-lending-dapp/

Agora seu DeFi dApp está público e funcional na testnet Sepolia.

Github: https://github.com/adrianotavares/defi-lending-dapp
dApp: https://adrianotavares.github.io/defi-lending-dapp/

No exemplo prático apresentado, o contrato de empréstimo mostra como a confiança é substituída por regras matemáticas: o depósito, o cálculo de juros e a devolução do valor são executados automaticamente pelo código, sem necessidade de bancos, gestores ou contratos em papel.

O DeFi vai além da tecnologia. É a educação financeira transformada em código.

Cada função do contrato representa um princípio financeiro clássico, como crédito, garantia e liquidação, mas de forma transparente, auditável e acessível a qualquer pessoa com uma carteira digital.

Assim, entender o DeFi é mais do que aprender Solidity ou interagir com carteiras: é compreender como a programação e as finanças se fundem para criar um sistema econômico global, aberto e colaborativo.

A cada linha de código, surgem novas formas de confiança que não são centralizadas em instituições, mas em protocolo, transparência e criptografia.

#7 DeFi na Prática: construindo um dApp de empréstimos na Blockchain

Comments