arc-devkit 0.2.0__py3-none-any.whl

arc_devkit/cli/commands/agent.py

@@ -0,0 +1,176 @@
+"""Comandos CLI para gerenciamento de carteiras e agentes Arc."""
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+app = typer.Typer(help="Gerenciamento de carteiras e agentes econômicos Arc.")
+console = Console()
+
+
+@app.command(name="create-wallet")
+def create_wallet() -> None:
+    """
+    Cria uma nova carteira EVM e exibe endereço e chave privada.
+
+    A chave privada gerada é exibida UMA ÚNICA VEZ. Guarde em local seguro.
+    """
+    from arc_devkit.core.wallet import create_wallet as _criar
+
+    carteira = _criar()
+
+    console.print(
+        Panel(
+            f"[bold green]✓ Nova carteira criada![/bold green]\n\n"
+            f"  [bold]Endereço:[/bold]\n"
+            f"  [cyan]{carteira['address']}[/cyan]\n\n"
+            f"  [bold]Chave Privada:[/bold]\n"
+            f"  [dim]{carteira['private_key']}[/dim]\n\n"
+            "[bold red]⚠ ATENÇÃO:[/bold red] A chave privada é exibida apenas agora.\n"
+            "Guarde-a em local seguro. Nunca compartilhe ou commite no git.",
+            title="[bold green]Nova Carteira Arc[/bold green]",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )
+
+
+@app.command()
+def balance(
+    address: str = typer.Argument(..., help="Endereço EVM a consultar."),
+) -> None:
+    """Exibe o saldo de uma carteira na Arc testnet."""
+    from arc_devkit.core.wallet import get_balance
+
+    with console.status("[bold]Consultando saldo...[/bold]", spinner="dots"):
+        resultado = get_balance(address)
+
+    console.print(f"\n  [bold]Carteira:[/bold] [cyan]{resultado['address']}[/cyan]")
+    console.print(f"  [bold]Saldo:   [/bold] [green]{resultado['balance_usdc']}[/green] USDC\n")
+
+
+@app.command()
+def status() -> None:
+    """Exibe informações da rede Arc (bloco atual, chain ID, gas price)."""
+    from arc_devkit.core.connection import get_web3
+
+    with console.status("[bold]Consultando a rede Arc...[/bold]", spinner="dots"):
+        w3 = get_web3()
+        bloco = w3.eth.block_number
+        chain_id = w3.eth.chain_id
+        gas_price_gwei = w3.from_wei(w3.eth.gas_price, "gwei")
+        conectado = w3.is_connected()
+
+    tabela = Table(
+        title="Status da Rede Arc",
+        show_header=True,
+        header_style="bold magenta",
+        border_style="magenta",
+    )
+    tabela.add_column("Propriedade", style="bold", min_width=14)
+    tabela.add_column("Valor")
+
+    tabela.add_row("Conectado", "[green]✓ Sim[/green]" if conectado else "[red]✗ Não[/red]")
+    tabela.add_row("Bloco Atual", f"[bold]#{bloco}[/bold]")
+    tabela.add_row("Chain ID", str(chain_id))
+    tabela.add_row("Gas Price", f"{gas_price_gwei} gwei")
+
+    console.print(tabela)
+
+
+@app.command()
+def pay(
+    to: str = typer.Argument(..., help="Endereço EVM de destino."),
+    amount: float = typer.Argument(..., help="Valor a transferir (em USDC)."),
+    send: bool = typer.Option(False, "--send", help="Envia a transação à rede (requer ARC_PRIVATE_KEY)."),
+    private_key: str = typer.Option("", "--key", help="Chave privada (sobrescreve ARC_PRIVATE_KEY)."),
+) -> None:
+    """
+    Prepara (e opcionalmente envia) um pagamento na Arc.
+
+    Sem --send, exibe a transação assinada sem enviá-la (modo seguro padrão).
+
+    Exemplos:
+      arcdevkit agent pay 0xDest... 5.0
+      arcdevkit agent pay 0xDest... 5.0 --send
+      arcdevkit agent pay 0xDest... 5.0 --send --key 0xSUAKEY...
+    """
+    from arc_devkit.agents.payment_agent import PaymentAgent
+
+    agente = PaymentAgent(private_key=private_key or None)
+
+    with console.status(
+        f"[bold green]{'Enviando' if send else 'Preparando'} pagamento de {amount} USDC → {to[:10]}...[/bold green]",
+        spinner="dots",
+    ):
+        resultado = agente.execute(to=to, amount_usdc=amount, enviar=send)
+
+    if resultado.get("status") == "erro":
+        console.print(f"\n[red]✗ Erro:[/red] {resultado.get('error')}\n")
+        raise typer.Exit(1)
+
+    tabela = Table(
+        title="Pagamento Arc",
+        show_header=True,
+        header_style="bold green",
+        border_style="green",
+    )
+    tabela.add_column("Campo", style="bold", min_width=14)
+    tabela.add_column("Valor")
+
+    tabela.add_row("Status", f"[green]{resultado['status']}[/green]")
+    tabela.add_row("De", resultado.get("from", "N/A"))
+    tabela.add_row("Para", resultado.get("to", "N/A"))
+    tabela.add_row("Valor", f"{resultado.get('amount_usdc', amount)} USDC")
+
+    if resultado.get("tx_hash"):
+        tabela.add_row("TX Hash", f"[cyan]{resultado['tx_hash']}[/cyan]")
+    if resultado.get("nota"):
+        tabela.add_row("Nota", f"[dim]{resultado['nota']}[/dim]")
+
+    console.print(tabela)
+
+
+@app.command()
+def monitor(
+    address: str = typer.Argument(..., help="Endereço EVM a monitorar."),
+    interval: int = typer.Option(15, "--interval", "-i", help="Intervalo de polling em segundos."),
+    max_iter: int = typer.Option(0, "--max", help="Número máximo de iterações (0 = infinito)."),
+) -> None:
+    """
+    Monitora uma carteira Arc e exibe alertas ao detectar mudanças de saldo.
+
+    Pressione Ctrl+C para encerrar o monitoramento.
+
+    Exemplos:
+      arcdevkit agent monitor 0xCarteira...
+      arcdevkit agent monitor 0xCarteira... --interval 5 --max 20
+    """
+    from arc_devkit.agents.monitor_agent import MonitorAgent
+
+    def _callback(evento: dict) -> None:
+        tipo = evento["tipo"]
+        diferenca_wei = int(evento["diferenca_wei"])
+        cor = "green" if tipo == "credito" else "red"
+        sinal = "+" if tipo == "credito" else "-"
+        console.print(
+            f"  [{cor}]{sinal}{abs(diferenca_wei)} wei ({tipo})[/{cor}]"
+            f" → saldo: {evento['saldo_atual_wei']} wei"
+        )
+
+    agente = MonitorAgent(watched_address=address, interval_seconds=interval)
+
+    console.print(
+        Panel.fit(
+            f"[bold]Monitorando:[/bold] [cyan]{address}[/cyan]\n"
+            f"[dim]Intervalo: {interval}s  |  Ctrl+C para parar[/dim]",
+            border_style="magenta",
+        )
+    )
+
+    try:
+        agente.execute(callback=_callback, max_iterations=max_iter)
+    except KeyboardInterrupt:
+        agente.stop()
+        console.print("\n[dim]Monitoramento encerrado.[/dim]\n")

arc_devkit/cli/commands/copilot.py

@@ -0,0 +1,40 @@
+"""Comandos CLI para o Dev Copilot."""
+
+import typer
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+
+app = typer.Typer(help="Assistente de IA para desenvolvimento na Arc blockchain.")
+console = Console()
+
+
+@app.command()
+def ask(
+    prompt: str = typer.Argument(..., help="Pergunta ou instrução para o Dev Copilot."),
+) -> None:
+    """
+    Envia uma pergunta ao Dev Copilot e exibe a resposta formatada.
+
+    Exemplos:
+      arcdevkit copilot ask "Como criar uma carteira na Arc?"
+      arcdevkit copilot ask "Gere um contrato ERC-20 para Arc testnet"
+    """
+    from arc_devkit.copilot.agent import DevCopilot
+
+    copilot = DevCopilot()
+
+    with console.status(
+        "[bold cyan]Consultando Dev Copilot...[/bold cyan]",
+        spinner="dots",
+    ):
+        resposta = copilot.ask(prompt)
+
+    console.print(
+        Panel(
+            Markdown(resposta),
+            title="[bold cyan]Dev Copilot[/bold cyan]",
+            border_style="cyan",
+            padding=(1, 2),
+        )
+    )

arc_devkit/cli/commands/debug.py

@@ -0,0 +1,110 @@
+"""Comandos CLI para o Tx Debugger."""
+
+import typer
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.table import Table
+
+app = typer.Typer(help="Análise e debug de transações Arc.")
+console = Console()
+
+
+@app.command()
+def tx(
+    tx_hash: str = typer.Argument(..., help="Hash da transação a analisar (0x...)."),
+    json_output: bool = typer.Option(False, "--json", help="Exibir resultado em JSON bruto."),
+) -> None:
+    """
+    Analisa uma transação Arc e exibe diagnóstico completo.
+
+    Exemplos:
+      arcdevkit debug tx 0xabc123...
+      arcdevkit debug tx 0xabc123... --json
+    """
+    import json
+
+    from arc_devkit.debugger.tx_analyzer import TxAnalyzer
+
+    analyzer = TxAnalyzer()
+
+    with console.status(
+        f"[bold yellow]Analisando transação {tx_hash[:16]}...[/bold yellow]",
+        spinner="dots",
+    ):
+        resultado = analyzer.analyze(tx_hash)
+
+    # Saída JSON bruto
+    if json_output:
+        console.print_json(json.dumps(resultado, default=str))
+        return
+
+    # Tabela resumo
+    status = resultado.get("status", "desconhecido")
+    cor_status = "green" if status == "sucesso" else "red"
+    icone = "✓" if status == "sucesso" else "✗"
+
+    tabela = Table(
+        title=f"Transação [dim]{tx_hash[:20]}...[/dim]",
+        show_header=True,
+        header_style="bold yellow",
+        border_style="yellow",
+    )
+    tabela.add_column("Campo", style="bold", min_width=14)
+    tabela.add_column("Valor")
+
+    tabela.add_row("Hash", f"{tx_hash[:20]}...")
+    tabela.add_row("Status", f"[{cor_status}]{icone} {status}[/{cor_status}]")
+    tabela.add_row("Custo Gás", f"{resultado.get('custo_usdc', 'N/A')} USDC")
+
+    if resultado.get("erro"):
+        tabela.add_row("Erro", f"[red]{resultado['erro']}[/red]")
+
+    console.print(tabela)
+
+    # Análise em linguagem natural (se disponível)
+    if resultado.get("resumo"):
+        console.print(
+            Panel(
+                Markdown(resultado["resumo"]),
+                title="[bold yellow]Análise[/bold yellow]",
+                border_style="yellow",
+                padding=(1, 2),
+            )
+        )
+
+
+@app.command()
+def estimate(
+    to: str = typer.Argument(..., help="Endereço EVM de destino."),
+    amount: float = typer.Argument(..., help="Valor a transferir (em USDC)."),
+    from_address: str = typer.Option("", "--from", help="Endereço remetente (opcional)."),
+) -> None:
+    """
+    Estima o custo de gás para uma transferência na Arc.
+
+    Exemplos:
+      arcdevkit debug estimate 0xDest... 10.5
+      arcdevkit debug estimate 0xDest... 10.5 --from 0xRemetente...
+    """
+    from arc_devkit.core.gas import estimate_transfer
+
+    with console.status("[bold]Estimando custo de gás...[/bold]", spinner="dots"):
+        est = estimate_transfer(to, amount, from_address or None)
+
+    tabela = Table(
+        title="Estimativa de Gás",
+        show_header=True,
+        header_style="bold blue",
+        border_style="blue",
+    )
+    tabela.add_column("Campo", style="bold", min_width=16)
+    tabela.add_column("Valor")
+
+    tabela.add_row("Destino", est["to"])
+    tabela.add_row("Transferência", f"{amount} USDC")
+    tabela.add_row("Gas Limit", str(est["gas_limit"]))
+    tabela.add_row("Gas Price", f"{est['gas_price_gwei']} gwei")
+    tabela.add_row("Custo de Gás", f"[bold green]{est['custo_usdc']}[/bold green] USDC")
+
+    console.print(tabela)

arc_devkit/cli/main.py

@@ -0,0 +1,69 @@
+"""Entry point da CLI Arc DevKit — construída com Typer."""
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from arc_devkit import __version__
+from arc_devkit.cli.commands import agent, copilot, debug
+
+# Aplicação Typer principal
+app = typer.Typer(
+    name="arcdevkit",
+    help="[bold cyan]Arc DevKit[/bold cyan] — Ferramentas para desenvolvedores da Arc blockchain.",
+    add_completion=True,
+    rich_markup_mode="rich",
+    no_args_is_help=False,
+)
+
+# Registrar grupos de subcomandos
+app.add_typer(copilot.app, name="copilot", help="Assistente de IA para desenvolvimento Arc.")
+app.add_typer(agent.app, name="agent", help="Gerenciamento de carteiras e agentes.")
+app.add_typer(debug.app, name="debug", help="Análise e debug de transações.")
+
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-v", help="Exibe a versão instalada."),
+) -> None:
+    """Arc DevKit — Ferramentas para desenvolvedores da Arc blockchain."""
+    if version:
+        console.print(f"[bold]Arc DevKit[/bold] v{__version__}")
+        raise typer.Exit()
+
+    # Exibir banner se nenhum subcomando foi invocado
+    if ctx.invoked_subcommand is None:
+        console.print(
+            Panel.fit(
+                f"[bold cyan]Arc DevKit[/bold cyan] [dim]v{__version__}[/dim]\n\n"
+                "  [white]Ferramentas para desenvolvedores da Arc blockchain[/white]\n"
+                "  [dim]EVM · USDC como gás · Malachite (<1s)[/dim]\n\n"
+                "  Use [bold]arcdevkit --help[/bold] para ver os comandos.",
+                border_style="cyan",
+                padding=(1, 3),
+            )
+        )
+
+
+@app.command()
+def status() -> None:
+    """Verifica a conexão com a Arc testnet e exibe informações da rede."""
+    from arc_devkit.core.connection import check_connection, get_web3
+
+    console.print("\n[bold]Verificando conexão com a Arc...[/bold]\n")
+
+    if not check_connection():
+        console.print("[red]✗[/red] Não foi possível conectar à Arc.")
+        console.print("  Verifique se [bold]ARC_RPC_URL[/bold] está configurado corretamente.")
+        raise typer.Exit(1)
+
+    w3 = get_web3()
+    console.print("[green]✓[/green] Conectado à Arc testnet!\n")
+    console.print(f"  Bloco atual :  [bold]#{w3.eth.block_number}[/bold]")
+    console.print(f"  Chain ID    :  [bold]{w3.eth.chain_id}[/bold]")
+    console.print(
+        f"  Gas Price   :  [bold]{w3.from_wei(w3.eth.gas_price, 'gwei')} gwei[/bold]\n"
+    )

arc_devkit/config.py

@@ -0,0 +1,73 @@
+"""Carregamento e validação de configuração via variáveis de ambiente."""
+
+import logging
+import os
+from dataclasses import dataclass
+
+from dotenv import load_dotenv
+
+# Carregar .env antes de qualquer leitura de os.getenv
+load_dotenv()
+
+
+@dataclass(frozen=True)
+class Settings:
+    """Configurações globais do Arc DevKit, carregadas do ambiente."""
+
+    anthropic_api_key: str
+    arc_rpc_url: str
+    arc_chain_id: int
+    arc_private_key: str | None
+    log_level: str
+
+
+def _require(name: str) -> str:
+    """Retorna o valor da variável ou levanta erro descritivo."""
+    value = os.getenv(name, "").strip()
+    if not value:
+        raise EnvironmentError(
+            f"\n\n  Variável obrigatória '{name}' não está configurada.\n"
+            f"  Crie um arquivo .env baseado no .env.example e defina {name}.\n"
+            f"  Exemplo: cp .env.example .env\n"
+        )
+    return value
+
+
+def _load_settings() -> Settings:
+    """Lê, valida e retorna todas as configurações do ambiente."""
+    # Coletar erros de uma só vez para exibição agrupada
+    erros: list[str] = []
+
+    api_key = os.getenv("ANTHROPIC_API_KEY", "").strip()
+    rpc_url = os.getenv("ARC_RPC_URL", "").strip()
+
+    if not api_key:
+        erros.append("ANTHROPIC_API_KEY")
+    if not rpc_url:
+        erros.append("ARC_RPC_URL")
+
+    if erros:
+        lista = ", ".join(erros)
+        raise EnvironmentError(
+            f"\n\n  Variáveis obrigatórias não configuradas: {lista}\n"
+            f"  Execute: cp .env.example .env  e preencha os valores.\n"
+        )
+
+    return Settings(
+        anthropic_api_key=api_key,
+        arc_rpc_url=rpc_url,
+        arc_chain_id=int(os.getenv("ARC_CHAIN_ID", "7777777")),
+        arc_private_key=os.getenv("ARC_PRIVATE_KEY", "").strip() or None,
+        log_level=os.getenv("LOG_LEVEL", "INFO").upper(),
+    )
+
+
+# Objeto global — importado por todos os módulos
+settings = _load_settings()
+
+# Configurar logging global com o nível definido no .env
+logging.basicConfig(
+    level=getattr(logging, settings.log_level, logging.INFO),
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)

arc_devkit/copilot/__init__.py

@@ -0,0 +1,5 @@
+"""Módulo Dev Copilot — assistente de IA para desenvolvimento na Arc."""
+
+from arc_devkit.copilot.agent import DevCopilot
+
+__all__ = ["DevCopilot"]

arc_devkit/copilot/agent.py

@@ -0,0 +1,74 @@
+"""Dev Copilot — assistente de IA especializado na Arc blockchain."""
+
+import logging
+
+import anthropic
+
+from arc_devkit.config import settings
+
+logger = logging.getLogger(__name__)
+
+# System prompt com contexto completo da Arc e boas práticas de resposta
+_SYSTEM_PROMPT = """\
+Você é um assistente especializado em desenvolvimento na Arc blockchain.
+
+## Sobre a Arc
+- Layer 1 EVM-compatível desenvolvida pela Circle (criadores do USDC)
+- USDC é o token de gás (não ETH) — custo sempre expresso em USDC
+- Consenso Malachite: finalidade em menos de 1 segundo por bloco
+- Circle Agent Stack: infraestrutura nativa para agentes econômicos autônomos
+- Testnet ativa desde outubro de 2025; mainnet prevista para verão de 2026
+- RPC EVM padrão: compatível com web3.py, ethers.js, Hardhat, Foundry
+
+## Diretrizes de resposta
+1. Gere sempre código Python funcional com comentários em português brasileiro
+2. Use web3.py para toda interação com a blockchain Arc
+3. Use Decimal (nunca float) para todos os valores monetários em USDC
+4. Informe o custo estimado em USDC quando relevante para a operação
+5. Separe claramente a explicação do bloco de código
+6. Se houver risco de segurança (chaves privadas, valores altos), alerte o usuário
+"""
+
+
+class DevCopilot:
+    """
+    Assistente de IA para desenvolvimento na Arc blockchain.
+
+    Usa o modelo claude-sonnet-4-6 da Anthropic com contexto especializado
+    em Arc, EVM, USDC e agentes econômicos.
+    """
+
+    # Modelo usado — definido em nível de classe para facilitar override em testes
+    MODEL = "claude-sonnet-4-6"
+    MAX_TOKENS = 1500
+
+    def __init__(self) -> None:
+        # Cliente Anthropic instanciado uma única vez e reutilizado
+        self._client = anthropic.Anthropic(api_key=settings.anthropic_api_key)
+        logger.debug("DevCopilot inicializado com modelo %s", self.MODEL)
+
+    def ask(self, prompt: str) -> str:
+        """
+        Envia uma pergunta ao Dev Copilot e retorna a resposta completa.
+
+        Args:
+            prompt: Pergunta ou instrução do desenvolvedor.
+
+        Returns:
+            Resposta formatada com explicação e código (Markdown).
+
+        Raises:
+            anthropic.APIError: Em caso de erro na API Anthropic.
+        """
+        logger.info("Dev Copilot consultado — prompt: %.80s...", prompt)
+
+        message = self._client.messages.create(
+            model=self.MODEL,
+            max_tokens=self.MAX_TOKENS,
+            system=_SYSTEM_PROMPT,
+            messages=[{"role": "user", "content": prompt}],
+        )
+
+        resposta = message.content[0].text
+        logger.info("Resposta recebida: %d caracteres", len(resposta))
+        return resposta

arc_devkit/core/__init__.py

@@ -0,0 +1 @@
+"""Módulo core — conexão RPC e operações de carteira Arc."""

arc_devkit/core/connection.py

@@ -0,0 +1,50 @@
+"""Conexão com a Arc blockchain via web3.py."""
+
+import logging
+
+from web3 import Web3
+from web3.middleware import ExtraDataToPOAMiddleware
+
+logger = logging.getLogger(__name__)
+
+
+def get_web3() -> Web3:
+    """
+    Retorna instância Web3 conectada ao nó RPC configurado em ARC_RPC_URL.
+
+    Aplica o middleware PoA necessário para redes EVM que usam blocos
+    com extraData maior que 32 bytes (comum em testnets).
+    """
+    from arc_devkit.config import settings
+
+    w3 = Web3(Web3.HTTPProvider(settings.arc_rpc_url))
+
+    # Middleware necessário para compatibilidade com redes PoA/testnets
+    w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+
+    return w3
+
+
+def check_connection() -> bool:
+    """
+    Testa a conexão com o nó RPC da Arc.
+
+    Returns:
+        True se conectado com sucesso, False caso contrário.
+    """
+    try:
+        w3 = get_web3()
+        if w3.is_connected():
+            bloco = w3.eth.block_number
+            chain_id = w3.eth.chain_id
+            logger.info(
+                "Conectado à Arc! Bloco: #%d | Chain ID: %d", bloco, chain_id
+            )
+            return True
+
+        logger.warning("Web3 instanciado mas is_connected() retornou False.")
+        return False
+
+    except Exception as exc:
+        logger.error("Falha ao conectar ao Arc RPC: %s", exc)
+        return False

arc_devkit/core/gas.py

@@ -0,0 +1,62 @@
+"""Estimativa de custo de gás para transações Arc."""
+
+import logging
+from decimal import Decimal
+
+from web3 import Web3
+
+from arc_devkit.core.connection import get_web3
+
+logger = logging.getLogger(__name__)
+
+# Custo fixo de transferência nativa (ETH/USDC) em unidades de gás
+GAS_TRANSFERENCIA = 21_000
+
+
+def estimate_transfer(to: str, amount_usdc: float, from_address: str | None = None) -> dict:
+    """
+    Estima o custo de gás para uma transferência nativa na Arc.
+
+    Args:
+        to: Endereço EVM de destino.
+        amount_usdc: Valor a transferir (em USDC).
+        from_address: Endereço remetente (opcional — usado para estimativa mais precisa).
+
+    Returns:
+        Dict com gas_limit, gas_price_gwei, custo_usdc e custo_wei.
+    """
+    w3 = get_web3()
+
+    destino = Web3.to_checksum_address(to)
+    gas_price_wei = w3.eth.gas_price
+    gas_price_gwei = Decimal(str(w3.from_wei(gas_price_wei, "gwei")))
+
+    # Para transferências nativas o gás é fixo em 21.000
+    # Para contratos, usa eth_estimateGas (mais preciso mas requer from_address)
+    if from_address:
+        try:
+            remetente = Web3.to_checksum_address(from_address)
+            gas_limit = w3.eth.estimate_gas({
+                "from": remetente,
+                "to": destino,
+                "value": w3.to_wei(amount_usdc, "ether"),
+            })
+        except Exception:
+            gas_limit = GAS_TRANSFERENCIA
+    else:
+        gas_limit = GAS_TRANSFERENCIA
+
+    custo_wei = gas_limit * gas_price_wei
+    custo_usdc = Decimal(str(w3.from_wei(custo_wei, "ether")))
+
+    logger.debug("Estimativa: %d gas × %s gwei = %s USDC", gas_limit, gas_price_gwei, custo_usdc)
+
+    return {
+        "gas_limit": gas_limit,
+        "gas_price_gwei": str(gas_price_gwei),
+        "gas_price_wei": str(gas_price_wei),
+        "custo_usdc": str(custo_usdc),
+        "custo_wei": str(custo_wei),
+        "amount_usdc": amount_usdc,
+        "to": str(destino),
+    }