DeFi para Iniciantes 2026: Guia Completo de Finanças Descentralizadas no Brasil

┌─────────────────────────────────────────────────────────────────┐
│                    ECOSSISTEMA DeFi                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    CAMADA BASE                           │   │
│  │    Ethereum, Solana, Arbitrum, Polygon, BSC              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                            │                                    │
│            ┌───────────────┼───────────────┐                   │
│            ▼               ▼               ▼                   │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            │
│  │    DEXs     │  │   LENDING   │  │   STAKING   │            │
│  │  Uniswap    │  │    Aave     │  │    Lido     │            │
│  │  Curve      │  │  Compound   │  │  Rocket Pool│            │
│  └─────────────┘  └─────────────┘  └─────────────┘            │
│            │               │               │                   │
│            └───────────────┼───────────────┘                   │
│                            ▼                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                 AGREGADORES                              │   │
│  │    1inch, Yearn Finance, DefiLlama                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                            │                                    │
│                            ▼                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              STABLECOINS                                 │   │
│  │    USDT, USDC, DAI, FRAX                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    LIQUID STAKING (Lido)                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│     Você                                   Lido Protocol        │
│       │                                         │               │
│       │ Deposita 1 ETH                         │               │
│       ├────────────────────────────────────────▶│               │
│       │                                         │               │
│       │ Recebe 1 stETH                         │               │
│       │◀────────────────────────────────────────┤               │
│       │                                         │               │
│       ▼                                         ▼               │
│  ┌─────────────┐                       ┌─────────────────┐     │
│  │   stETH     │                       │  ETH Staking    │     │
│  │  (líquido)  │                       │  (validação)    │     │
│  └──────┬──────┘                       └────────┬────────┘     │
│         │                                       │               │
│         ▼                                       ▼               │
│  ┌─────────────────────────┐           ┌─────────────────┐     │
│  │ Usar como colateral     │           │ Recompensas     │     │
│  │ em Aave, Compound, etc  │           │ ~3.5% APY       │     │
│  └─────────────────────────┘           └─────────────────┘     │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

from dataclasses import dataclass
from typing import Tuple

@dataclass
class LiquidityPool:
    """
    Simulação de uma Liquidity Pool AMM (Automated Market Maker).
    Modelo: Constant Product (x * y = k)
    """
    token_a: str
    token_b: str
    reserve_a: float
    reserve_b: float
    fee_percent: float = 0.3  # 0.3% por trade (Uniswap v2)
    
    @property
    def k(self) -> float:
        """Constante do produto."""
        return self.reserve_a * self.reserve_b
    
    @property
    def price_a_in_b(self) -> float:
        """Preço de A em termos de B."""
        return self.reserve_b / self.reserve_a
    
    @property
    def price_b_in_a(self) -> float:
        """Preço de B em termos de A."""
        return self.reserve_a / self.reserve_b
    
    def swap_a_for_b(self, amount_a: float) -> Tuple[float, float]:
        """
        Troca token A por token B.
        Retorna: (amount_b_out, fee_paid)
        """
        # Deduzir taxa
        fee = amount_a * (self.fee_percent / 100)
        amount_a_after_fee = amount_a - fee
        
        # Novo reserve_a
        new_reserve_a = self.reserve_a + amount_a_after_fee
        
        # Calcular reserve_b para manter k constante
        new_reserve_b = self.k / new_reserve_a
        
        # Quantidade de B recebida
        amount_b_out = self.reserve_b - new_reserve_b
        
        # Atualizar reservas
        self.reserve_a = new_reserve_a
        self.reserve_b = new_reserve_b
        
        return (amount_b_out, fee)
    
    def add_liquidity(
        self, 
        amount_a: float, 
        amount_b: float
    ) -> float:
        """
        Adiciona liquidez ao pool.
        Retorna: quantidade de LP tokens recebidos.
        """
        # Calcular proporção
        ratio_a = amount_a / self.reserve_a
        ratio_b = amount_b / self.reserve_b
        
        # Usar a menor proporção para manter o ratio
        ratio = min(ratio_a, ratio_b)
        
        # Atualizar reservas
        self.reserve_a += amount_a
        self.reserve_b += amount_b
        
        # LP tokens proporcionais à contribuição
        lp_tokens = ratio * 100  # Simplificado
        
        return lp_tokens
    
    def estimate_impermanent_loss(
        self, 
        price_change_ratio: float
    ) -> float:
        """
        Estima impermanent loss dado uma mudança de preço.
        price_change_ratio: nova_razão / razão_original
        Exemplo: se ETH dobrou de valor vs USDC, ratio = 2.0
        """
        r = price_change_ratio
        il = (2 * (r ** 0.5) / (1 + r)) - 1
        return il * 100  # Retorna em porcentagem


# Exemplo: Pool ETH/USDC
pool = LiquidityPool(
    token_a="ETH",
    token_b="USDC",
    reserve_a=100,      # 100 ETH
    reserve_b=300000,   # 300,000 USDC
    fee_percent=0.3
)

print("=" * 60)
print("SIMULAÇÃO DE LIQUIDITY POOL")
print("=" * 60)
print(f"Pool: {pool.token_a}/{pool.token_b}")
print(f"Reservas: {pool.reserve_a} {pool.token_a} / {pool.reserve_b:,.0f} {pool.token_b}")
print(f"Preço 1 {pool.token_a} = {pool.price_a_in_b:,.2f} {pool.token_b}")
print(f"Constante k = {pool.k:,.0f}")
print()

# Simular swap
print("SWAP: 5 ETH → USDC")
amount_out, fee = pool.swap_a_for_b(5)
print(f"  Recebido: {amount_out:,.2f} USDC")
print(f"  Taxa paga: {fee:.4f} ETH")
print(f"  Novo preço: 1 ETH = {pool.price_a_in_b:,.2f} USDC")
print(f"  Slippage: {((3000 - pool.price_a_in_b) / 3000) * 100:.2f}%")
print()

# Impermanent Loss
print("IMPERMANENT LOSS (se ETH valorizar):")
for change in [1.5, 2.0, 3.0, 5.0]:
    il = pool.estimate_impermanent_loss(change)
    print(f"  ETH {change}x → IL: {il:.2f}%")

┌─────────────────────────────────────────────────────────────────┐
│                 ESTRATÉGIA DE YIELD FARMING                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  1. DEPÓSITO INICIAL                                            │
│     └─▶ Depositar ETH no Lido                                   │
│           └─▶ Receber stETH (3.5% APY)                          │
│                                                                 │
│  2. COLATERAL                                                   │
│     └─▶ Depositar stETH no Aave como colateral                  │
│           └─▶ Ganhar APY extra (1-2%)                           │
│                                                                 │
│  3. EMPRÉSTIMO                                                  │
│     └─▶ Emprestar stablecoins (USDC) do Aave                    │
│           └─▶ Pagar juros (~3%)                                 │
│                                                                 │
│  4. LIQUIDITY MINING                                            │
│     └─▶ Adicionar USDC a pool no Curve                          │
│           └─▶ Ganhar taxas + tokens CRV (5-15% APY)             │
│                                                                 │
│  ═══════════════════════════════════════════════════════════   │
│  RENDIMENTO COMPOSTO: 10-20% APY                                │
│  RISCO: Smart contract, liquidação, impermanent loss            │
│  ═══════════════════════════════════════════════════════════   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

def calcular_emprestimo_defi(
    colateral_valor: float,
    ltv_maximo: float = 0.75,  # 75% Loan-to-Value
    threshold_liquidacao: float = 0.80  # 80%
) -> dict:
    """
    Calcula parâmetros de empréstimo DeFi.
    
    Args:
        colateral_valor: Valor do colateral em USD
        ltv_maximo: Percentual máximo de empréstimo
        threshold_liquidacao: Quando ocorre liquidação
    """
    emprestimo_maximo = colateral_valor * ltv_maximo
    emprestimo_seguro = emprestimo_maximo * 0.70  # Margem de segurança
    
    # Preço de liquidação
    preco_liquidacao_relativo = threshold_liquidacao / ltv_maximo
    
    return {
        'colateral': colateral_valor,
        'emprestimo_maximo': emprestimo_maximo,
        'emprestimo_recomendado': emprestimo_seguro,
        'ltv_maximo': f"{ltv_maximo * 100}%",
        'threshold_liquidacao': f"{threshold_liquidacao * 100}%",
        'risco': 'ALTO' if ltv_maximo > 0.7 else 'MODERADO'
    }


# Exemplo: Depositar $10.000 em ETH como colateral
resultado = calcular_emprestimo_defi(10000)

print("SIMULAÇÃO DE EMPRÉSTIMO DeFi")
print("=" * 50)
print(f"Colateral depositado: ${resultado['colateral']:,.2f}")
print(f"LTV máximo: {resultado['ltv_maximo']}")
print(f"Empréstimo máximo: ${resultado['emprestimo_maximo']:,.2f}")
print(f"Empréstimo recomendado: ${resultado['emprestimo_recomendado']:,.2f}")
print(f"Threshold de liquidação: {resultado['threshold_liquidacao']}")
print()
print("⚠️  Se o valor do colateral cair 20%, você será LIQUIDADO!")

┌─────────────────────────────────────────────────────────────────┐
│                    PENDLE FINANCE                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Ativo Original (stETH)                                         │
│          │                                                      │
│          ▼                                                      │
│     ┌─────────┐                                                 │
│     │ Pendle  │                                                 │
│     └────┬────┘                                                 │
│          │                                                      │
│     ┌────┴────┐                                                 │
│     ▼         ▼                                                 │
│  ┌─────┐   ┌─────┐                                             │
│  │ PT  │   │ YT  │                                             │
│  │Token│   │Token│                                             │
│  │Princ│   │Yield│                                             │
│  └─────┘   └─────┘                                             │
│     │         │                                                 │
│     │         └──▶ Recebe todos os yields até maturidade       │
│     │                                                           │
│     └──▶ Recebe principal no vencimento (desconto)             │
│                                                                 │
│  Estratégias:                                                   │
│  • Comprar PT = renda fixa (trava APY)                         │
│  • Comprar YT = aposta em APY subir                            │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

from dataclasses import dataclass
from enum import Enum

class NivelRisco(Enum):
    BAIXO = 1
    MEDIO = 2
    ALTO = 3
    MUITO_ALTO = 4


@dataclass
class RiscoDeFi:
    nome: str
    descricao: str
    nivel: NivelRisco
    mitigacao: str


RISCOS_DEFI = [
    RiscoDeFi(
        nome="Smart Contract Risk",
        descricao="Bugs ou vulnerabilidades no código do protocolo",
        nivel=NivelRisco.ALTO,
        mitigacao="Use apenas protocolos auditados e estabelecidos"
    ),
    RiscoDeFi(
        nome="Impermanent Loss",
        descricao="Perda ao fornecer liquidez quando preços divergem",
        nivel=NivelRisco.MEDIO,
        mitigacao="Use pools de stablecoins ou ativos correlacionados"
    ),
    RiscoDeFi(
        nome="Liquidation Risk",
        descricao="Perda de colateral se posição for liquidada",
        nivel=NivelRisco.ALTO,
        mitigacao="Mantenha LTV baixo (máx 50%) e monitore posições"
    ),
    RiscoDeFi(
        nome="Rug Pull",
        descricao="Desenvolvedores roubam fundos dos usuários",
        nivel=NivelRisco.MUITO_ALTO,
        mitigacao="Evite projetos novos sem auditoria ou time anônimo"
    ),
    RiscoDeFi(
        nome="Oracle Manipulation",
        descricao="Manipulação de preços em oráculos",
        nivel=NivelRisco.MEDIO,
        mitigacao="Use protocolos com oráculos Chainlink"
    ),
    RiscoDeFi(
        nome="Regulatory Risk",
        descricao="Mudanças regulatórias que afetam acesso",
        nivel=NivelRisco.MEDIO,
        mitigacao="Diversifique entre jurisdições e protocolos"
    ),
]


def exibir_matriz_riscos():
    print("=" * 70)
    print("MATRIZ DE RISCOS DeFi")
    print("=" * 70)
    print()
    
    for risco in RISCOS_DEFI:
        nivel_emoji = {
            'BAIXO': "🟢",
            'MEDIO': "🟡",
            'ALTO': "🟠",
            'MUITO_ALTO': "🔴"
        }
        
        print(f"{nivel_emoji[risco.nivel]} {risco.nome}")
        print(f"   {risco.descricao}")
        print(f"   ✓ Mitigação: {risco.mitigacao}")
        print()


exibir_matriz_riscos()

import math

def calcular_impermanent_loss(price_ratio: float) -> dict:
    """
    Calcula Impermanent Loss para diferentes cenários.
    
    Args:
        price_ratio: nova_razão_de_preços / razão_original
                    (ex: 2.0 significa que um token dobrou vs o outro)
    """
    # Fórmula: IL = 2*sqrt(r)/(1+r) - 1
    il = (2 * math.sqrt(price_ratio) / (1 + price_ratio)) - 1
    
    # Valor se tivesse apenas segurado (HODL)
    hodl_value = (1 + price_ratio) / 2  # Média dos dois ativos
    
    # Valor no pool (LP)
    lp_value = math.sqrt(price_ratio)
    
    return {
        'price_ratio': price_ratio,
        'impermanent_loss': il * 100,
        'hodl_normalized': hodl_value,
        'lp_normalized': lp_value,
        'diferenca': (lp_value - hodl_value) * 100
    }


print("TABELA DE IMPERMANENT LOSS")
print("=" * 60)
print(f"{'Variação Preço':<20} {'IL %':<15} {'LP vs HODL':<20}")
print("-" * 60)

for ratio in [0.5, 0.75, 1.0, 1.25, 1.5, 2.0, 3.0, 4.0, 5.0]:
    resultado = calcular_impermanent_loss(ratio)
    
    if ratio < 1:
        variacao = f"Token A caiu {(1-ratio)*100:.0f}%"
    elif ratio > 1:
        variacao = f"Token A subiu {(ratio-1)*100:.0f}%"
    else:
        variacao = "Sem variação"
    
    print(f"{variacao:<20} {resultado['impermanent_loss']:.2f}%{'':<10} "
          f"{resultado['diferenca']:.2f}%")

print("-" * 60)
print("Nota: IL é 'impermanent' pois se preços voltarem, a perda desaparece")

TABELA DE IMPERMANENT LOSS
============================================================
Variação Preço       IL %            LP vs HODL           
------------------------------------------------------------
Token A caiu 50%     5.72%           -4.29%
Token A caiu 25%     1.03%           -0.89%
Sem variação         0.00%           0.00%
Token A subiu 25%    0.62%           -0.56%
Token A subiu 50%    2.02%           -1.96%
Token A subiu 100%   5.72%           -5.72%
Token A subiu 200%   13.40%          -15.47%
Token A subiu 300%   20.00%          -25.00%
Token A subiu 400%   25.46%          -33.33%

┌─────────────────────────────────────────────────────────────────┐
│           FORNECENDO LIQUIDEZ NO UNISWAP V3                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  PASSO 1: Preparação                                            │
│  ─────────────────────────────────────────────────────────────  │
│  □ Conecte sua carteira em app.uniswap.org                     │
│  □ Tenha ETH e outro token (ex: USDC) na proporção desejada    │
│  □ Reserve ETH extra para gas (~$10-50)                        │
│                                                                 │
│  PASSO 2: Selecionar Pool                                       │
│  ─────────────────────────────────────────────────────────────  │
│  □ Vá em "Pools" → "New Position"                              │
│  □ Selecione o par (ex: ETH/USDC)                              │
│  □ Escolha a fee tier:                                         │
│      0.01% = stablecoins                                       │
│      0.05% = pairs correlacionados                             │
│      0.30% = pairs padrão (mais comum)                         │
│      1.00% = pairs exóticos                                    │
│                                                                 │
│  PASSO 3: Definir Range de Preço                                │
│  ─────────────────────────────────────────────────────────────  │
│  □ Escolha min/max price (liquidez concentrada)                │
│  □ Range menor = mais fees, mais IL                            │
│  □ Range maior = menos fees, menos IL                          │
│  □ "Full Range" = comportamento v2 (menos eficiente)           │
│                                                                 │
│  PASSO 4: Depositar                                             │
│  ─────────────────────────────────────────────────────────────  │
│  □ Insira quantidade de tokens                                 │
│  □ Aprove os tokens (se primeira vez)                          │
│  □ Confirme a transação "Add Liquidity"                        │
│  □ Aguarde confirmação na blockchain                           │
│                                                                 │
│  PASSO 5: Monitorar                                             │
│  ─────────────────────────────────────────────────────────────  │
│  □ Acompanhe sua posição em "Pools"                            │
│  □ Verifique se preço está dentro do range                     │
│  □ Colete fees periodicamente                                  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

def guia_staking_lido():
    """
    Guia passo a passo para staking de ETH no Lido.
    """
    passos = [
        {
            'numero': 1,
            'titulo': 'Acessar o Lido',
            'acoes': [
                'Acesse stake.lido.fi',
                'Conecte sua carteira (MetaMask, WalletConnect, etc.)',
                'Verifique se está na rede Ethereum Mainnet'
            ]
        },
        {
            'numero': 2,
            'titulo': 'Fazer Stake',
            'acoes': [
                'Digite a quantidade de ETH para stake',
                'Clique em "Submit"',
                'Confirme a transação na carteira',
                'Pague o gas (geralmente $5-30)'
            ]
        },
        {
            'numero': 3,
            'titulo': 'Receber stETH',
            'acoes': [
                'Receba stETH 1:1 na sua carteira',
                'stETH gera ~3.5% APY automaticamente',
                'Saldo de stETH aumenta diariamente (rebase)'
            ]
        },
        {
            'numero': 4,
            'titulo': 'Usar stETH (opcional)',
            'acoes': [
                'Usar como colateral no Aave',
                'Fornecer liquidez em Curve (stETH/ETH)',
                'Simplesmente segurar e acumular rendimentos'
            ]
        },
        {
            'numero': 5,
            'titulo': 'Sacar (unstake)',
            'acoes': [
                'Opção 1: Request withdrawal (pode levar dias)',
                'Opção 2: Swap stETH → ETH em DEX (instantâneo)',
                'DEX pode ter pequeno desconto/prêmio'
            ]
        }
    ]
    
    print("=" * 60)
    print("GUIA: STAKING DE ETH NO LIDO")
    print("=" * 60)
    
    for passo in passos:
        print(f"\n📌 PASSO {passo['numero']}: {passo['titulo']}")
        print("-" * 40)
        for acao in passo['acoes']:
            print(f"   □ {acao}")
    
    print("\n" + "=" * 60)
    print("💡 DICAS:")
    print("   • Mínimo: Não há mínimo para stake no Lido")
    print("   • Gas: Espere gas baixo (<30 gwei) para economizar")
    print("   • APY: Confira APY atual em lido.fi/ethereum")
    print("=" * 60)


guia_staking_lido()

from typing import Optional
from datetime import datetime, timedelta

def simular_rendimento_defi(
    capital_inicial: float,
    apy: float,
    periodo_dias: int = 365,
    composicao: str = 'diario',
    taxa_gas_mensal: float = 0
) -> dict:
    """
    Simula rendimentos em protocolos DeFi.
    
    Args:
        capital_inicial: Valor inicial em USD
        apy: Taxa anual (ex: 0.10 = 10%)
        periodo_dias: Período de investimento
        composicao: 'diario', 'semanal', 'mensal'
        taxa_gas_mensal: Custo mensal de gas para compound
    """
    periodos_por_ano = {
        'diario': 365,
        'semanal': 52,
        'mensal': 12
    }
    
    n = periodos_por_ano.get(composicao, 365)
    t = periodo_dias / 365
    
    # Juros compostos: A = P(1 + r/n)^(nt)
    capital_final = capital_inicial * ((1 + apy / n) ** (n * t))
    
    # Deduzir custos de gas
    meses = periodo_dias / 30
    custo_gas_total = taxa_gas_mensal * meses
    capital_final -= custo_gas_total
    
    rendimento_bruto = capital_final - capital_inicial + custo_gas_total
    rendimento_liquido = capital_final - capital_inicial
    
    return {
        'capital_inicial': capital_inicial,
        'apy': f"{apy * 100:.1f}%",
        'periodo_dias': periodo_dias,
        'composicao': composicao,
        'rendimento_bruto': round(rendimento_bruto, 2),
        'custo_gas': round(custo_gas_total, 2),
        'rendimento_liquido': round(rendimento_liquido, 2),
        'capital_final': round(capital_final, 2),
        'apy_liquido': round((capital_final / capital_inicial - 1) / t * 100, 2)
    }


# Comparar diferentes estratégias
print("=" * 70)
print("COMPARATIVO DE ESTRATÉGIAS DeFi")
print("=" * 70)
print()

estrategias = [
    ("Staking ETH (Lido)", 0.035, 5),
    ("Pool stETH/ETH (Curve)", 0.05, 10),
    ("USDC Supply (Aave)", 0.04, 5),
    ("ETH/USDC LP (Uniswap)", 0.15, 20),
    ("Yield Farming Agressivo", 0.30, 50),
]

capital = 10000  # $10,000

print(f"Capital inicial: ${capital:,.2f}")
print(f"Período: 1 ano")
print()
print(f"{'Estratégia':<30} {'APY':<10} {'Lucro Liq.':<15} {'Final':<15}")
print("-" * 70)

for nome, apy, gas_mensal in estrategias:
    resultado = simular_rendimento_defi(capital, apy, 365, 'diario', gas_mensal)
    print(f"{nome:<30} {resultado['apy']:<10} "
          f"${resultado['rendimento_liquido']:>10,.2f}   "
          f"${resultado['capital_final']:>10,.2f}")

print("-" * 70)
print("* Custos de gas estimados por estratégia")
print("* APYs são variáveis e podem mudar significativamente")