Update app.py

Commit ini train

app.py

@@ -1,750 +1,751 @@
-# rnn/app.py
-
-import os
-import uuid
-import time
-import hmac
-import hashlib
-import json
-from datetime import datetime, timedelta
-from typing import Dict, Any, List, Optional
-from rnn.app.ccxt_utils import get_ccxt_exchange, fetch_crypto_data
-
-import httpx # Para fazer chamadas HTTP assíncronas (para o callback)
-from fastapi import FastAPI, Request, HTTPException, Depends, Header, BackgroundTasks
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse, JSONResponse
-from fastapi.staticfiles import StaticFiles
-from jinja2 import Environment, FileSystemLoader
-from pydantic import BaseModel, Field
-
-from rnn.app.model.rnn_predictor import RNNModelPredictor
-from rnn.app.utils.logger import get_logger 
-
-
-
-logger = get_logger()
-
-# --- Configuração Inicial e Variáveis de Ambiente (Secrets do Hugging Face) ---
-AIBANK_API_KEY = os.environ.get("AIBANK_API_KEY") # Chave que o aibank usa para chamar esta API RNN
-AIBANK_CALLBACK_URL = os.environ.get("AIBANK_CALLBACK_URL") # URL no aibank para onde esta API RNN enviará o resultado
-CALLBACK_SHARED_SECRET = os.environ.get("CALLBACK_SHARED_SECRET") # Segredo para assinar/verificar o payload do callback
-
-# Chaves para serviços externos 
-MARKET_DATA_API_KEY = os.environ.get("MARKET_DATA_API_KEY")
-EXCHANGE_API_KEY = os.environ.get("EXCHANGE_API_KEY")
-EXCHANGE_API_SECRET = os.environ.get("EXCHANGE_API_SECRET")
-
-if not AIBANK_API_KEY:
-    logger.warning("AIBANK_API_KEY não configurada. A autenticação para /api/invest falhou.")
-if not AIBANK_CALLBACK_URL:
-    logger.warning("AIBANK_CALLBACK_URL não configurada. O callback para o aibank falhou.")
-if not CALLBACK_SHARED_SECRET:
-    logger.warning("CALLBACK_SHARED_SECRET não configurado. A segurança do callback está comprometida.")
-
-
-
-
-app = FastAPI(title="ATCoin Neural Agents - Investment API")
-
-# --- Middlewares ---
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[
-        "http://localhost:3000",  # URL desenvolvimento local
-        "http://aibank.app.br",   # URL de produção 
-        "https://*.aibank.app.br", # subdomínios
-        "https://*.hf.space"      # HF Space
-    ],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# --- Simulação de Banco de Dados de Transações DEV ---
-# Em produção  MongoDB
-transactions_db: Dict[str, Dict[str, Any]] = {}
-
-# --- Modelos Pydantic ---
-class InvestmentRequest(BaseModel):
-    client_id: str
-    amount: float = Field(..., gt=0) # Garante que o montante seja positivo
-    aibank_transaction_token: str # Token único gerado pelo aibank para rastreamento
-
-class InvestmentResponse(BaseModel):
-    status: str
-    message: str
-    rnn_transaction_id: str # ID da transação this.API
-
-class InvestmentResultPayload(BaseModel): # Payload para o callback para o aibank
-    rnn_transaction_id: str
-    aibank_transaction_token: str
-    client_id: str
-    initial_amount: float
-    final_amount: float
-    profit_loss: float
-    status: str #  "completed", "failed"
-    timestamp: datetime
-    details: str = ""
-
-
-# --- Dependência de Autenticação ---
-async def verify_aibank_key(authorization: str = Header(None)):
-    if not AIBANK_API_KEY: # Checagem se a chave do servidor está configurada
-        logger.error("CRITICAL: AIBANK_API_KEY (server-side) não está configurada nos Secrets.")
-        raise HTTPException(status_code=500, detail="Internal Server Configuration Error: Missing server API Key.")
-
-    if authorization is None:
-        logger.warning("Authorization header ausente na chamada do AIBank.")
-        raise HTTPException(status_code=401, detail="Authorization header is missing")
-
-    parts = authorization.split()
-    if len(parts) != 2 or parts[0].lower() != 'bearer':
-        logger.warning(f"Formato inválido do Authorization header: {authorization}")
-        raise HTTPException(status_code=401, detail="Authorization header must be 'Bearer <token>'")
-
-    token_from_aibank = parts[1]
-    if not hmac.compare_digest(token_from_aibank, AIBANK_API_KEY):
-        logger.warning(f"Chave de API inválida fornecida pelo AIBank. Token: {token_from_aibank[:10]}...")
-        raise HTTPException(status_code=403, detail="Invalid API Key provided by AIBank.")
-    logger.info("API Key do AIBank verificada com sucesso.")
-    return True
-
-
-# --- Lógica de Negócio Principal (Simulada e em Background) ---
-
-
-async def execute_investment_strategy_background(
-    rnn_tx_id: str,
-    client_id: str,
-    amount: float,
-    aibank_tx_token: str
-):
-    logger.info(f"BG TASK [{rnn_tx_id}]: Iniciando estratégia de investimento para cliente {client_id}, valor {amount}.")
-    transactions_db[rnn_tx_id]["status"] = "processing"
-    transactions_db[rnn_tx_id]["status_details"] = "Initializing investment cycle"
-    
-    final_status = "completed"
-    error_details = "" # Acumula mensagens de erro de várias etapas
-    calculated_final_amount = amount 
-
-    # Inicializa a exchange ccxt usando o utilitário
-    # O logger do app.py é passado para ccxt_utils para que os logs apareçam no mesmo stream
-    exchange = await get_ccxt_exchange(logger_instance=logger) # MODIFICADO
-
-    if not exchange:
-        # get_ccxt_exchange já loga o erro. Se a exchange é crucial, podemos falhar aqui.
-        logger.warning(f"BG TASK [{rnn_tx_id}]: Falha ao inicializar a exchange. A estratégia pode não funcionar como esperado para cripto.")
-        # Se as chaves CCXT foram fornecidas no ambiente mas a exchange falhou, considere isso um erro de config.
-        if os.environ.get("CCXT_API_KEY") and os.environ.get("CCXT_API_SECRET"):
-            error_details += "Failed to initialize CCXT exchange despite API keys being present; "
-            final_status = "failed_config" 
-            # (PULAR PARA CALLBACK - veja a seção de tratamento de erro crítico abaixo)
-    
-    # =========================================================================
-    # 1. COLETAR DADOS DE MERCADO
-    # =========================================================================
-    logger.info(f"BG TASK [{rnn_tx_id}]: Coletando dados de mercado...")
-    transactions_db[rnn_tx_id]["status_details"] = "Fetching market data"
-    market_data_results = {"crypto": {}, "stocks": {}, "other": {}}
-    critical_data_fetch_failed = False # Flag para falha crítica na coleta de dados
-
-    # --- Coleta de dados de Cripto via ccxt_utils ---
-    if exchange:
-        crypto_pairs_to_fetch = ["BTC/USDT", "ETH/USDT", "SOL/USDT"] # Mantenha configurável
-        
-        crypto_data, crypto_fetch_ok, crypto_err_msg = await fetch_crypto_data(
-            exchange, 
-            crypto_pairs_to_fetch, 
-            logger_instance=logger
-        )
-        market_data_results["crypto"] = crypto_data
-        if not crypto_fetch_ok:
-            error_details += f"Crypto data fetch issues: {crypto_err_msg}; "
-            # Decida se a falha na coleta de cripto é crítica
-            # Se for, defina critical_data_fetch_failed = True
-            if os.environ.get("CCXT_API_KEY"): # Se esperávamos dados de cripto
-                critical_data_fetch_failed = True 
-                logger.error(f"BG TASK [{rnn_tx_id}]: Falha crítica na coleta de dados de cripto.")
-    else:
-        logger.info(f"BG TASK [{rnn_tx_id}]: Instância da exchange ccxt não disponível. Pulando coleta de dados de cripto.")
-        if os.environ.get("CCXT_API_KEY"): # Se esperávamos dados de cripto mas a exchange não inicializou
-            error_details += "CCXT exchange not initialized, crypto data skipped; "
-            critical_data_fetch_failed = True
-
-
-    # --- Coleta de dados para outros tipos de ativos (ex: Ações com yfinance) ---
-    # (Sua lógica yfinance aqui, se aplicável, similarmente atualizando market_data_results["stocks"])
-    # try:
-    #     import yfinance as yf # Mova para o topo do app.py se for usar
-    #     # ... lógica yfinance ...
-    # except Exception as e_yf:
-    #     logger.warning(f"BG TASK [{rnn_tx_id}]: Falha ao buscar dados de ações com yfinance: {e_yf}")
-    #     error_details += f"YFinance data fetch failed: {str(e_yf)}; "
-    #     # Decida se isso é crítico: critical_data_fetch_failed = True
-
-    market_data_results["other"]['simulated_index_level'] = random.uniform(10000, 15000) # Mantém simulação
-    
-    transactions_db[rnn_tx_id]["market_data_collected"] = market_data_results
-    
-    # --- PONTO DE CHECAGEM PARA FALHA CRÍTICA NA COLETA DE DADOS ---
-    if critical_data_fetch_failed:
-        final_status = "failed_market_data"
-        logger.error(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado falhou criticamente. {error_details}")
-        # Pular para a seção de callback
-        # (A lógica de envio do callback precisa ser alcançada)
-    else:
-        logger.info(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado concluída.")
-        transactions_db[rnn_tx_id]["status_details"] = "Processing RNN analysis"
-
-
-
-
-
-    # =========================================================================
-    # 2. ANÁLISE PELA RNN E TOMADA DE DECISÃO
-    # =========================================================================
-    investment_decisions: List[Dict[str, Any]] = [] 
-    total_usd_allocated_by_rnn = 0.0
-    loop = asyncio.get_running_loop() 
-
-    if final_status == "completed": 
-        logger.info(f"BG TASK [{rnn_tx_id}]: Executando análise RNN...")
-        transactions_db[rnn_tx_id]["status_details"] = "Running RNN model"
-        rnn_analysis_success = True
-        
-        # CORRIGIDO: Acessando app.state.rnn_predictor
-        predictor: Optional[RNNModelPredictor] = getattr(app.state, 'rnn_predictor', None)
-
-        try:
-                crypto_data_for_rnn = market_data_results.get("crypto", {})
-                candidate_assets = [
-                    asset_key for asset_key, data in crypto_data_for_rnn.items() 
-                    if data and not data.get("error") and data.get("ohlcv_1h") # Apenas com dados válidos
-                ]
-                
-                # --- Parâmetros de Gerenciamento de Risco e Alocação (AJUSTE FINO É CRUCIAL) ---
-                # Risco total do portfólio para este ciclo (ex: não usar mais que 50% do capital total em novas posições)
-                MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE = 0.75 # Usar até 75% do 'amount'
-                
-                # Risco por ativo individual (percentual do 'amount' TOTAL)
-                MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL = 0.15 # Ex: máx 15% do capital total em UM ativo
-                MIN_ALLOCATION_PER_ASSET_PCT_OF_TOTAL = 0.02 # Ex: mín 2% do capital total para valer a pena
-
-                MIN_USD_PER_ORDER = 25.00     # Mínimo de USD por ordem
-                MAX_CONCURRENT_POSITIONS = 4  # Máximo de posições abertas simultaneamente
-                
-                # Limiares de Confiança da RNN
-                CONFIDENCE_STRONG_BUY = 0.80 # Confiança para considerar uma alocação maior
-                CONFIDENCE_MODERATE_BUY = 0.65 # Confiança mínima para considerar uma alocação base
-                CONFIDENCE_WEAK_BUY = 0.55    # Confiança para uma alocação muito pequena ou nenhuma
-
-                allocated_capital_this_cycle = 0.0
-                
-                # Para diversificação, podemos querer limitar a avaliação ou dar pesos
-                # random.shuffle(candidate_assets) 
-
-                for asset_key in candidate_assets:
-                    if len(investment_decisions) >= MAX_CONCURRENT_POSITIONS:
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de {MAX_CONCURRENT_POSITIONS} posições concorrentes atingido.")
-                        break
-                    
-                    # Verifica se já usamos o capital máximo para o ciclo
-                    if allocated_capital_this_cycle >= amount * MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE:
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de capital para o ciclo ({MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE*100}%) atingido.")
-                        break
-
-                    asset_symbol = asset_key.replace("_", "/")
-                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN avaliando ativo: {asset_symbol}")
-                    
-                    signal, confidence_prob = await predictor.predict_for_asset(
-                        crypto_data_for_rnn[asset_key], 
-                        loop=loop
-                    )
-
-                    if signal == 1 and confidence_prob is not None: # Sinal de COMPRA e confiança válida
-                        target_usd_allocation = 0.0
-
-                        if confidence_prob >= CONFIDENCE_STRONG_BUY:
-                            # Alocação maior para sinais fortes
-                            # Ex: entre 60% e 100% da alocação máxima permitida por ativo
-                            alloc_factor = 0.6 + 0.4 * ((confidence_prob - CONFIDENCE_STRONG_BUY) / (1.0 - CONFIDENCE_STRONG_BUY + 1e-6))
-                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
-                            reason = f"RNN STRONG BUY signal (Conf: {confidence_prob:.3f})"
-                        elif confidence_prob >= CONFIDENCE_MODERATE_BUY:
-                            # Alocação base para sinais moderados
-                            # Ex: entre 30% e 60% da alocação máxima permitida por ativo
-                            alloc_factor = 0.3 + 0.3 * ((confidence_prob - CONFIDENCE_MODERATE_BUY) / (CONFIDENCE_STRONG_BUY - CONFIDENCE_MODERATE_BUY + 1e-6))
-                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
-                            reason = f"RNN MODERATE BUY signal (Conf: {confidence_prob:.3f})"
-                        elif confidence_prob >= CONFIDENCE_WEAK_BUY:
-                             # Alocação pequena para sinais fracos (ou nenhuma)
-                            alloc_factor = 0.1 + 0.2 * ((confidence_prob - CONFIDENCE_WEAK_BUY) / (CONFIDENCE_MODERATE_BUY - CONFIDENCE_WEAK_BUY + 1e-6))
-                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
-                            reason = f"RNN WEAK BUY signal (Conf: {confidence_prob:.3f})"
-                        else:
-                            logger.info(f"BG TASK [{rnn_tx_id}]: Sinal COMPRA para {asset_symbol} mas confiança ({confidence_prob:.3f}) abaixo do limiar WEAK_BUY ({CONFIDENCE_WEAK_BUY}). Pulando.")
-                            continue
-                        
-                        # Garantir que a alocação não seja menor que a mínima permitida (percentual do total)
-                        target_usd_allocation = max(target_usd_allocation, amount * MIN_ALLOCATION_PER_ASSET_PCT_OF_TOTAL)
-
-                        # Garantir que não exceda o capital restante disponível neste CICLO
-                        capital_left_for_this_cycle = (amount * MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE) - allocated_capital_this_cycle
-                        actual_usd_allocation = min(target_usd_allocation, capital_left_for_this_cycle)
-                        
-                        # Garantir que a ordem mínima em USD seja respeitada
-                        if actual_usd_allocation < MIN_USD_PER_ORDER:
-                            logger.info(f"BG TASK [{rnn_tx_id}]: Alocação final ({actual_usd_allocation:.2f}) para {asset_symbol} abaixo do mínimo de ordem ({MIN_USD_PER_ORDER}). Pulando.")
-                            continue
-                        
-                        # Adicionar à lista de decisões
-                        investment_decisions.append({
-                            "asset_id": asset_symbol, "type": "CRYPTO", "action": "BUY",
-                            "target_usd_amount": round(actual_usd_allocation, 2),
-                            "rnn_confidence": round(confidence_prob, 4),
-                            "reasoning": reason
-                        })
-                        allocated_capital_this_cycle += round(actual_usd_allocation, 2)
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Decisão: COMPRAR {actual_usd_allocation:.2f} USD de {asset_symbol}. {reason}")
-                    
-                    # ... (restante da lógica para signal 0 ou None) ...
-        except Exception as e: # Captura exceções da lógica da RNN
-                logger.error(f"BG TASK [{rnn_tx_id}]: Erro CRÍTICO durante análise/predição RNN: {str(e)}", exc_info=True)
-                rnn_analysis_success = False # Marca que a análise RNN falhou
-                error_details += f"Critical RNN analysis/prediction error: {str(e)}; "
-
-
-        total_usd_allocated_by_rnn = allocated_capital_this_cycle 
-      
-      
-        
-
-        if not predictor or not predictor.model: # Verifica se o preditor e o modelo interno existem
-            logger.warning(f"BG TASK [{rnn_tx_id}]: Instância do preditor RNN não disponível ou modelo interno não carregado. Pulando análise RNN.")
-            rnn_analysis_success = False 
-            error_details += "RNN model/predictor not available for prediction; "
-        else:
-            try:
-                # ... (lógica de iteração sobre `candidate_assets` e chamada a `predictor.predict_for_asset` como na resposta anterior)
-                # ... (lógica de alocação de capital como na resposta anterior)
-                # Garantir que toda essa lógica está dentro deste bloco 'else'
-                crypto_data_for_rnn = market_data_results.get("crypto", {})
-                candidate_assets = [
-                    asset_key for asset_key, data in crypto_data_for_rnn.items() 
-                    if data and not data.get("error") and data.get("ohlcv_1h")
-                ]
-                
-                MAX_RISK_PER_ASSET_PCT = 0.05 
-                MIN_USD_PER_ORDER = 20.00    
-                MAX_CONCURRENT_POSITIONS = 5 
-                CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC = 0.85 
-                CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC = 0.60 
-                BASE_ALLOCATION_PCT_OF_TOTAL_CAPITAL = 0.10 
-
-                allocated_capital_this_cycle = 0.0
-                
-                for asset_key in candidate_assets:
-                    if len(investment_decisions) >= MAX_CONCURRENT_POSITIONS:
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de posições concorrentes ({MAX_CONCURRENT_POSITIONS}) atingido.")
-                        break
-                    if allocated_capital_this_cycle >= amount * 0.90:
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de capital do ciclo atingido.")
-                        break
-
-                    asset_symbol = asset_key.replace("_", "/")
-                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN avaliando ativo: {asset_symbol}")
-                    
-                    signal, confidence_prob = await predictor.predict_for_asset(
-                        crypto_data_for_rnn[asset_key], 
-                        loop=loop
-                        # window_size e expected_features serão os defaults de rnn_predictor.py
-                        # ou podem ser passados explicitamente se você quiser variar por ativo
-                    )
-
-                    if signal == 1: 
-                        if confidence_prob is None or confidence_prob < CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC:
-                            logger.info(f"BG TASK [{rnn_tx_id}]: Sinal COMPRA para {asset_symbol} mas confiança ({confidence_prob}) abaixo do mínimo {CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC}. Pulando.")
-                            continue
-
-                        confidence_factor = 0.5 
-                        if confidence_prob >= CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC:
-                            confidence_factor = 1.0
-                        elif confidence_prob > CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC: 
-                            confidence_factor = 0.5 + 0.5 * (
-                                (confidence_prob - CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC) /
-                                (CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC - CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC)
-                            )
-                        
-                        potential_usd_allocation = amount * BASE_ALLOCATION_PCT_OF_TOTAL_CAPITAL * confidence_factor
-                        potential_usd_allocation = min(potential_usd_allocation, amount * MAX_RISK_PER_ASSET_PCT)
-                        remaining_capital_for_cycle = amount - allocated_capital_this_cycle # Recalcula a cada iteração
-                        actual_usd_allocation = min(potential_usd_allocation, remaining_capital_for_cycle)
-
-                        if actual_usd_allocation < MIN_USD_PER_ORDER:
-                            logger.info(f"BG TASK [{rnn_tx_id}]: Alocação calculada ({actual_usd_allocation:.2f}) para {asset_symbol} abaixo do mínimo ({MIN_USD_PER_ORDER}). Pulando.")
-                            continue
-                        
-                        investment_decisions.append({
-                            "asset_id": asset_symbol, "type": "CRYPTO", "action": "BUY",
-                            "target_usd_amount": round(actual_usd_allocation, 2),
-                            "rnn_confidence": round(confidence_prob, 4) if confidence_prob is not None else None,
-                            "reasoning": f"RNN signal BUY for {asset_symbol} with confidence {confidence_prob:.2f}"
-                        })
-                        allocated_capital_this_cycle += round(actual_usd_allocation, 2)
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Decisão: COMPRAR {actual_usd_allocation:.2f} USD de {asset_symbol} (Conf: {confidence_prob:.2f})")
-                    
-                    elif signal == 0: 
-                        logger.info(f"BG TASK [{rnn_tx_id}]: RNN sinal NÃO COMPRAR para {asset_symbol} (Conf: {confidence_prob:.2f if confidence_prob is not None else 'N/A'})")
-                    else: 
-                        logger.warning(f"BG TASK [{rnn_tx_id}]: RNN não gerou sinal para {asset_symbol}.")
-                
-                if not investment_decisions:
-                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN não gerou decisões de COMPRA válidas após avaliação e alocação.")
-            
-            except Exception as e: # Captura exceções da lógica da RNN
-                logger.error(f"BG TASK [{rnn_tx_id}]: Erro CRÍTICO durante análise/predição RNN: {str(e)}", exc_info=True)
-                rnn_analysis_success = False # Marca que a análise RNN falhou
-                error_details += f"Critical RNN analysis/prediction error: {str(e)}; "
-        
-        if not rnn_analysis_success: # Se a flag foi setada para False
-            final_status = "failed_rnn_analysis" 
-        
-        transactions_db[rnn_tx_id]["rnn_decisions"] = investment_decisions
-    
-    total_usd_allocated_by_rnn = allocated_capital_this_cycle 
-    transactions_db[rnn_tx_id]["status_details"] = "Preparing to execute orders"
-
-   
-   
-
-
-
-
-
-
-
-    # =========================================================================
-    # 3. EXECUÇÃO DE ORDENS (Só executa se a RNN não falhou e gerou ordens)
-    # =========================================================================
-    executed_trades_info: List[Dict[str, Any]] = []
-    current_portfolio_value = 0.0 # Valor dos ativos comprados, baseado no custo
-    cash_remaining_after_execution = amount # Começa com todo o montante
-    
-    if final_status == "completed" and investment_decisions and exchange:
-        logger.info(f"BG TASK [{rnn_tx_id}]: Executando {len(investment_decisions)} ordens...")
-        transactions_db[rnn_tx_id]["status_details"] = "Executing investment orders"
-        order_execution_overall_success = True
-
-        # Placeholder para LÓGICA REAL DE EXECUÇÃO DE ORDENS (CREATE_ORDER_PLACEHOLDER)
-        # Esta seção precisa ser preenchida com:
-        # 1. Iterar sobre `investment_decisions`.
-        # 2. Para cada decisão de "BUY":
-        #    a. Determinar o símbolo correto na exchange (ex: "BTC/USDT").
-        #    b. Obter o preço atual (ticker) para calcular a quantidade de ativo a comprar.
-        #       `amount_of_asset = target_usd_amount / current_price_of_asset`
-        #    c. Considerar saldo disponível na exchange (se estiver gerenciando isso).
-        #    d. Criar a ordem via `await exchange.create_market_buy_order(symbol, amount_of_asset)`
-        #       ou `create_limit_buy_order(symbol, amount_of_asset, limit_price)`.
-        #       Para ordens limite, a RNN precisaria fornecer o `limit_price`.
-        #    e. Tratar respostas da exchange (sucesso, falha, ID da ordem).
-        #       `ccxt.InsufficientFunds`, `ccxt.InvalidOrder`, etc.
-        #    f. Armazenar detalhes da ordem em `executed_trades_info`:
-        #       { "asset_id": ..., "order_id_exchange": ..., "type": "market/limit", "side": "buy",
-        #         "requested_usd_amount": ..., "asset_quantity_ordered": ..., 
-        #         "status_from_exchange": ..., "filled_quantity": ..., "average_fill_price": ...,
-        #         "cost_in_usd": ..., "fees_paid": ..., "timestamp": ... }
-        #    g. Atualizar `current_portfolio_value` com o `cost_in_usd` da ordem preenchida.
-        #    h. Deduzir `cost_in_usd` de `cash_remaining_after_execution`.
-        # 3. Para decisões de "SELL" (se sua RNN gerar):
-        #    a. Verificar se você possui o ativo (requer gerenciamento de portfólio).
-        #    b. Criar ordem de venda.
-        #    c. Atualizar `current_portfolio_value` e `cash_remaining_after_execution`.
-
-        # Simulação atual:
-        for decision in investment_decisions:
-            if decision.get("action") == "BUY" and decision.get("type") == "CRYPTO":
-                asset_symbol = decision["asset_id"]
-                usd_to_spend = decision["target_usd_amount"]
-                
-                # Simular pequena chance de falha na ordem
-                if random.random() < 0.05:
-                    logger.warning(f"BG TASK [{rnn_tx_id}]: Falha simulada ao executar ordem para {asset_symbol}.")
-                    executed_trades_info.append({
-                        "asset_id": asset_symbol, "status": "failed_simulated", 
-                        "requested_usd_amount": usd_to_spend, "error": "Simulated exchange rejection"
-                    })
-                    order_execution_overall_success = False # Marca que pelo menos uma falhou
-                    continue # Pula para a próxima decisão
-
-                # Simular slippage e custo
-                simulated_cost = usd_to_spend * random.uniform(0.995, 1.005) # +/- 0.5% slippage
-                
-                # Garantir que não estamos gastando mais do que o caixa restante
-                if simulated_cost > cash_remaining_after_execution:
-                    simulated_cost = cash_remaining_after_execution # Gasta apenas o que tem
-                    if simulated_cost < 1: # Se não há quase nada, não faz a ordem
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Saldo insuficiente ({cash_remaining_after_execution:.2f}) para ordem de {asset_symbol}, pulando.")
-                        continue
-
-
-                if simulated_cost > 0:
-                    current_portfolio_value += simulated_cost
-                    cash_remaining_after_execution -= simulated_cost
-                    executed_trades_info.append({
-                        "asset_id": asset_symbol, "order_id_exchange": f"sim_ord_{uuid.uuid4()}",
-                        "type": "market", "side": "buy",
-                        "requested_usd_amount": usd_to_spend,
-                        "status_from_exchange": "filled", "cost_in_usd": round(simulated_cost, 2),
-                        "timestamp": datetime.utcnow().isoformat()
-                    })
-                    logger.info(f"BG TASK [{rnn_tx_id}]: Ordem simulada para {asset_symbol} (custo: {simulated_cost:.2f} USD) preenchida.")
-        
-        await asyncio.sleep(random.uniform(1, 2) * len(investment_decisions) if investment_decisions else 1)
-
-        if not order_execution_overall_success:
-            error_details += "One or more orders failed during execution; "
-            # Decida se isso torna o status final 'failed_order_execution' ou se 'completed_with_partial_failure'
-            # final_status = "completed_with_partial_failure" # Exemplo de um novo status
-    
-    elif not exchange and investment_decisions:
-        logger.warning(f"BG TASK [{rnn_tx_id}]: Decisões de investimento geradas, mas a exchange não está disponível para execução.")
-        error_details += "Exchange not available for order execution; "
-        final_status = "failed_order_execution" # Se a execução é crítica
-        cash_remaining_after_execution = amount # Nada foi gasto
-    
-    transactions_db[rnn_tx_id]["executed_trades"] = executed_trades_info
-    transactions_db[rnn_tx_id]["cash_after_execution"] = round(cash_remaining_after_execution, 2)
-    transactions_db[rnn_tx_id]["portfolio_value_after_execution"] = round(current_portfolio_value, 2)
-    
-
-    # =========================================================================
-    # 4. SIMULAÇÃO DO PERÍODO DE INVESTIMENTO E CÁLCULO DE LUCRO/PERDA (Só se não houve falha crítica antes)
-    # =========================================================================
-    value_of_investments_at_eod = current_portfolio_value # Começa com o valor de custo
-
-    if final_status == "completed": # Ou "completed_with_partial_failure"
-        transactions_db[rnn_tx_id]["status_details"] = "Simulating EOD valuation"
-        logger.info(f"BG TASK [{rnn_tx_id}]: Simulando valorização do portfólio no final do dia...")
-        await asyncio.sleep(random.uniform(3, 7)) 
-
-        if current_portfolio_value > 0:
-            # Simular mudança de valor do portfólio. A meta de 4.2% é sobre o capital INVESTIDO.
-            # O lucro/perda é aplicado ao `current_portfolio_value` (o que foi efetivamente comprado).
-            daily_return_factor = 0.042 # A meta
-            simulated_performance_factor = random.uniform(0.7, 1.3) # Variação em torno da meta (pode ser prejuízo)
-            # Para ser mais realista, o fator de performance deveria ser algo como:
-            # random.uniform(-0.05, 0.08) -> -5% a +8% de retorno diário sobre o investido (ainda alto)
-            # E não diretamente ligado à meta de 4.2%
-            
-            # Ajuste para uma simulação de retorno mais plausível (ainda agressiva)
-            # Suponha que o retorno diário real possa variar de -3% a +5% sobre o investido
-            actual_daily_return_on_portfolio = random.uniform(-0.03, 0.05) 
-            
-            profit_or_loss_on_portfolio = current_portfolio_value * actual_daily_return_on_portfolio
-            value_of_investments_at_eod = current_portfolio_value + profit_or_loss_on_portfolio
-            logger.info(f"BG TASK [{rnn_tx_id}]: Portfólio inicial: {current_portfolio_value:.2f}, Retorno simulado: {actual_daily_return_on_portfolio*100:.2f}%, "
-                        f"Lucro/Prejuízo no portfólio: {profit_or_loss_on_portfolio:.2f}, Valor EOD do portfólio: {value_of_investments_at_eod:.2f}")
-        else: 
-            logger.info(f"BG TASK [{rnn_tx_id}]: Nenhum portfólio para valorizar no EOD (nada foi comprado).")
-            value_of_investments_at_eod = 0.0
-        
-        # O calculated_final_amount é o valor dos investimentos liquidados + o caixa que não foi usado
-        calculated_final_amount = value_of_investments_at_eod + cash_remaining_after_execution
-    
-    else: # Se houve falha antes, o valor final é o que sobrou após a falha
-        calculated_final_amount = cash_remaining_after_execution + current_portfolio_value # current_portfolio_value pode ser 0 ou parcial
-        logger.warning(f"BG TASK [{rnn_tx_id}]: Ciclo de investimento não concluído normalmente ({final_status}). Valor final baseado no estado atual.")
-
-    transactions_db[rnn_tx_id]["eod_portfolio_value_simulated"] = round(value_of_investments_at_eod, 2)
-    transactions_db[rnn_tx_id]["final_calculated_amount"] = round(calculated_final_amount, 2)
-
-
-    # =========================================================================
-    # 5. TOKENIZAÇÃO / REGISTRO DA OPERAÇÃO (Só se não houve falha crítica antes)
-    # =========================================================================
-    if final_status not in ["failed_config", "failed_market_data", "failed_rnn_analysis"]: # Prossegue se ao menos tentou executar
-        transactions_db[rnn_tx_id]["status_details"] = "Finalizing transaction log (tokenization)"
-        logger.info(f"BG TASK [{rnn_tx_id}]: Registrando (tokenizando) operação detalhadamente...")
-        # Placeholder para LÓGICA REAL DE TOKENIZAÇÃO (TOKENIZATION_PLACEHOLDER)
-        # 1. Coletar todos os dados relevantes da transação de `transactions_db[rnn_tx_id]`
-        #    (market_data_collected, rnn_decisions, executed_trades, eod_portfolio_value_simulated, etc.)
-        # 2. Se for usar blockchain:
-        #    a. Preparar os dados para um contrato inteligente.
-        #    b. Interagir com o contrato (ex: web3.py para Ethereum).
-        #    c. Armazenar o hash da transação da blockchain.
-        # 3. Se for um registro interno avançado:
-        #    a. Assinar digitalmente os dados da transação.
-        #    b. Armazenar em um sistema de log imutável ou banco de dados com auditoria.
-        
-        # Simulação atual (hash dos dados da transação):
-        transaction_data_for_hash = {
-            "rnn_tx_id": rnn_tx_id, "client_id": client_id, "initial_amount": amount,
-            "final_amount_calculated": calculated_final_amount,
-            # Incluir resumos ou hashes dos dados coletados para não tornar o hash gigante
-            "market_data_summary_keys": list(transactions_db[rnn_tx_id].get("market_data_collected", {}).keys()),
-            "rnn_decisions_count": len(transactions_db[rnn_tx_id].get("rnn_decisions", [])),
-            "executed_trades_count": len(transactions_db[rnn_tx_id].get("executed_trades", [])),
-            "eod_portfolio_value": transactions_db[rnn_tx_id].get("eod_portfolio_value_simulated"),
-            "timestamp": datetime.utcnow().isoformat()
-        }
-        ordered_tx_data_str = json.dumps(transaction_data_for_hash, sort_keys=True)
-        proof_token_hash = hashlib.sha256(ordered_tx_data_str.encode('utf-8')).hexdigest()
-        
-        transactions_db[rnn_tx_id]["proof_of_operation_token"] = proof_token_hash
-        transactions_db[rnn_tx_id]["tokenization_method"] = "internal_summary_hash_proof"
-        await asyncio.sleep(0.5) # Simula tempo de escrita/hash
-        logger.info(f"BG TASK [{rnn_tx_id}]: Operação registrada. Prova (hash): {proof_token_hash[:10]}...")
-
-
-    # =========================================================================
-    # 6. PREPARAR E ENVIAR CALLBACK PARA AIBANK
-    # =========================================================================
-    if exchange and hasattr(exchange, 'close'):
-        try:
-            await exchange.close()
-            logger.info(f"BG TASK [{rnn_tx_id}]: Conexão ccxt fechada.")
-        except Exception as e_close: # Especificar o tipo de exceção se souber
-            logger.warning(f"BG TASK [{rnn_tx_id}]: Erro ao fechar conexão ccxt: {str(e_close)}")
-
-    if not AIBANK_CALLBACK_URL or not CALLBACK_SHARED_SECRET:
-        logger.error(f"BG TASK [{rnn_tx_id}]: Configuração de callback ausente. Não é possível notificar o AIBank.")
-        transactions_db[rnn_tx_id]["callback_status"] = "config_missing_critical"
-        return 
-
-    # Certifique-se que `final_status` reflete o estado real da operação
-    # Se `error_details` não estiver vazio e `final_status` ainda for "completed", ajuste-o
-    if error_details and final_status == "completed":
-        final_status = "completed_with_warnings" # Ou um status mais apropriado
-
-    callback_payload_data = InvestmentResultPayload(
-        rnn_transaction_id=rnn_tx_id, aibank_transaction_token=aibank_tx_token, client_id=client_id,
-        initial_amount=amount, final_amount=round(calculated_final_amount, 2), # Arredonda para 2 casas decimais
-        profit_loss=round(calculated_final_amount - amount, 2),
-        status=final_status, timestamp=datetime.utcnow(),
-        details=error_details if error_details else "Investment cycle processed."
-    )
-    payload_json_str = callback_payload_data.model_dump_json() # Garante que está usando a string serializada
-    
-    signature = hmac.new(CALLBACK_SHARED_SECRET.encode('utf-8'), payload_json_str.encode('utf-8'), hashlib.sha256).hexdigest()
-    headers = {'Content-Type': 'application/json', 'X-RNN-Signature': signature}
-
-    logger.info(f"BG TASK [{rnn_tx_id}]: Enviando callback para AIBank ({AIBANK_CALLBACK_URL}) com status final '{final_status}'. Payload: {payload_json_str}")
-    transactions_db[rnn_tx_id]["callback_status"] = "sending"
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client: # Timeout global para o cliente
-            response = await client.post(AIBANK_CALLBACK_URL, content=payload_json_str, headers=headers)
-            response.raise_for_status()
-            logger.info(f"BG TASK [{rnn_tx_id}]: Callback para AIBank enviado com sucesso. Resposta: {response.status_code}")
-            transactions_db[rnn_tx_id]["callback_status"] = f"sent_success_{response.status_code}"
-    except httpx.RequestError as e_req:
-        logger.error(f"BG TASK [{rnn_tx_id}]: Erro de REDE ao enviar callback para AIBank: {e_req}")
-        transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_network_error"
-    except httpx.HTTPStatusError as e_http:
-        logger.error(f"BG TASK [{rnn_tx_id}]: Erro HTTP do AIBank ao receber callback: {e_http.response.status_code} - {e_http.response.text[:200]}")
-        transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_http_error_{e_http.response.status_code}"
-    except Exception as e_cb_final:
-        logger.error(f"BG TASK [{rnn_tx_id}]: Erro INESPERADO ao enviar callback: {e_cb_final}", exc_info=True)
-        transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_unknown_error"
-
-
-import asyncio 
-import random  
-
-    
-
-# --- Endpoints da API ---
-@app.post("/api/invest",
-          response_model=InvestmentResponse,
-          dependencies=[Depends(verify_aibank_key)])
-async def initiate_investment(
-    request_data: InvestmentRequest,
-    background_tasks: BackgroundTasks
-):
-    """
-    Endpoint para o AIBank iniciar um ciclo de investimento.
-    Responde rapidamente e executa a lógica pesada em background.
-    """
-    logger.info(f"Requisição de investimento recebida para client_id: {request_data.client_id}, "
-                f"amount: {request_data.amount}, aibank_tx_token: {request_data.aibank_transaction_token}")
-
-    rnn_tx_id = str(uuid.uuid4())
-
-    # Armazena informações iniciais da transação DB real para ser mais robusto
-    transactions_db[rnn_tx_id] = {
-        "rnn_transaction_id": rnn_tx_id,
-        "aibank_transaction_token": request_data.aibank_transaction_token,
-        "client_id": request_data.client_id,
-        "initial_amount": request_data.amount,
-        "status": "pending_background_processing",
-        "received_at": datetime.utcnow().isoformat(),
-        "callback_status": "not_sent_yet"
-    }
-
-    # Adiciona a tarefa de longa duração ao background
-    background_tasks.add_task(
-        execute_investment_strategy_background,
-        rnn_tx_id,
-        request_data.client_id,
-        request_data.amount,
-        request_data.aibank_transaction_token
-    )
-
-    logger.info(f"Estratégia de investimento para rnn_tx_id: {rnn_tx_id} agendada para execução em background.")
-    return InvestmentResponse(
-        status="pending",
-        message="Investment request received and is being processed in the background. Await callback for results.",
-        rnn_transaction_id=rnn_tx_id
-    )
-
-@app.get("/api/transaction_status/{rnn_tx_id}", response_class=JSONResponse)
-async def get_transaction_status(rnn_tx_id: str):
-    """ Endpoint para verificar o status de uma transação (para debug/admin) """
-    transaction = transactions_db.get(rnn_tx_id)
-    if not transaction:
-        raise HTTPException(status_code=404, detail="Transaction not found")
-    return transaction
-
-
-# --- Dashboard (Existente, adaptado) ---
-# Setup para arquivos estáticos e templates
-
-try:
-    app.mount("/static", StaticFiles(directory="rnn/static"), name="static")
-    templates = Environment(loader=FileSystemLoader("rnn/templates"))
-except RuntimeError as e:
-    logger.warning(f"Não foi possível montar /static ou carregar templates: {e}. O dashboard pode não funcionar.")
-    templates = None # Para evitar erros se o loader falhar
-
-@app.get("/", response_class=HTMLResponse)
-async def index(request: Request):
-    if not templates:
-        return HTMLResponse("<html><body><h1>Dashboard indisponível</h1><p>Configuração de templates/estáticos falhou.</p></body></html>")
-    
-    agora = datetime.now()
-    agentes_simulados = [
-        # dados de agentes ...
-    ]
-    template = templates.get_template("index.html")
-    # Adicionar transações recentes ao contexto do template
-    recent_txs = list(transactions_db.values())[-5:] # Últimas 5 transações
-    return HTMLResponse(template.render(request=request, agentes=agentes_simulados, transactions=recent_txs))
-
-# --- Imports para Background Task ---
-import asyncio
-import random
-
-# Função de logger dummy 
-# class DummyLogger:
-#     def info(self, msg, *args, **kwargs): print(f"INFO: {msg}")
-#     def warning(self, msg, *args, **kwargs): print(f"WARNING: {msg}")
-#     def error(self, msg, *args, **kwargs): print(f"ERROR: {msg}", kwargs.get('exc_info'))
-
-# if __name__ == "__main__": # Para teste local
-#     # logger = DummyLogger() # se não tiver get_logger()
-#     # Configuração das variáveis de ambiente para teste local
-#     os.environ["AIBANK_API_KEY"] = "test_aibank_key_from_rnn_server"
-#     os.environ["AIBANK_CALLBACK_URL"] = "http://localhost:8001/api/rnn_investment_result_callback" # URL do aibank simulado
-#     os.environ["CALLBACK_SHARED_SECRET"] = "super_secret_for_callback_signing"
-#     # import uvicorn
+# rnn/app.py
+
+import agents.train_rl_portfolio_agent
+import os
+import uuid
+import time
+import hmac
+import hashlib
+import json
+from datetime import datetime, timedelta
+from typing import Dict, Any, List, Optional
+from rnn.app.ccxt_utils import get_ccxt_exchange, fetch_crypto_data
+
+import httpx # Para fazer chamadas HTTP assíncronas (para o callback)
+from fastapi import FastAPI, Request, HTTPException, Depends, Header, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from jinja2 import Environment, FileSystemLoader
+from pydantic import BaseModel, Field
+
+from rnn.app.model.rnn_predictor import RNNModelPredictor
+from rnn.app.utils.logger import get_logger 
+
+
+
+logger = get_logger()
+
+# --- Configuração Inicial e Variáveis de Ambiente (Secrets do Hugging Face) ---
+AIBANK_API_KEY = os.environ.get("AIBANK_API_KEY") # Chave que o aibank usa para chamar esta API RNN
+AIBANK_CALLBACK_URL = os.environ.get("AIBANK_CALLBACK_URL") # URL no aibank para onde esta API RNN enviará o resultado
+CALLBACK_SHARED_SECRET = os.environ.get("CALLBACK_SHARED_SECRET") # Segredo para assinar/verificar o payload do callback
+
+# Chaves para serviços externos 
+MARKET_DATA_API_KEY = os.environ.get("MARKET_DATA_API_KEY")
+EXCHANGE_API_KEY = os.environ.get("EXCHANGE_API_KEY")
+EXCHANGE_API_SECRET = os.environ.get("EXCHANGE_API_SECRET")
+
+if not AIBANK_API_KEY:
+    logger.warning("AIBANK_API_KEY não configurada. A autenticação para /api/invest falhou.")
+if not AIBANK_CALLBACK_URL:
+    logger.warning("AIBANK_CALLBACK_URL não configurada. O callback para o aibank falhou.")
+if not CALLBACK_SHARED_SECRET:
+    logger.warning("CALLBACK_SHARED_SECRET não configurado. A segurança do callback está comprometida.")
+
+
+
+
+app = FastAPI(title="ATCoin Neural Agents - Investment API")
+
+# --- Middlewares ---
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:3000",  # URL desenvolvimento local
+        "http://aibank.app.br",   # URL de produção 
+        "https://*.aibank.app.br", # subdomínios
+        "https://*.hf.space"      # HF Space
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Simulação de Banco de Dados de Transações DEV ---
+# Em produção  MongoDB
+transactions_db: Dict[str, Dict[str, Any]] = {}
+
+# --- Modelos Pydantic ---
+class InvestmentRequest(BaseModel):
+    client_id: str
+    amount: float = Field(..., gt=0) # Garante que o montante seja positivo
+    aibank_transaction_token: str # Token único gerado pelo aibank para rastreamento
+
+class InvestmentResponse(BaseModel):
+    status: str
+    message: str
+    rnn_transaction_id: str # ID da transação this.API
+
+class InvestmentResultPayload(BaseModel): # Payload para o callback para o aibank
+    rnn_transaction_id: str
+    aibank_transaction_token: str
+    client_id: str
+    initial_amount: float
+    final_amount: float
+    profit_loss: float
+    status: str #  "completed", "failed"
+    timestamp: datetime
+    details: str = ""
+
+
+# --- Dependência de Autenticação ---
+async def verify_aibank_key(authorization: str = Header(None)):
+    if not AIBANK_API_KEY: # Checagem se a chave do servidor está configurada
+        logger.error("CRITICAL: AIBANK_API_KEY (server-side) não está configurada nos Secrets.")
+        raise HTTPException(status_code=500, detail="Internal Server Configuration Error: Missing server API Key.")
+
+    if authorization is None:
+        logger.warning("Authorization header ausente na chamada do AIBank.")
+        raise HTTPException(status_code=401, detail="Authorization header is missing")
+
+    parts = authorization.split()
+    if len(parts) != 2 or parts[0].lower() != 'bearer':
+        logger.warning(f"Formato inválido do Authorization header: {authorization}")
+        raise HTTPException(status_code=401, detail="Authorization header must be 'Bearer <token>'")
+
+    token_from_aibank = parts[1]
+    if not hmac.compare_digest(token_from_aibank, AIBANK_API_KEY):
+        logger.warning(f"Chave de API inválida fornecida pelo AIBank. Token: {token_from_aibank[:10]}...")
+        raise HTTPException(status_code=403, detail="Invalid API Key provided by AIBank.")
+    logger.info("API Key do AIBank verificada com sucesso.")
+    return True
+
+
+# --- Lógica de Negócio Principal (Simulada e em Background) ---
+
+
+async def execute_investment_strategy_background(
+    rnn_tx_id: str,
+    client_id: str,
+    amount: float,
+    aibank_tx_token: str
+):
+    logger.info(f"BG TASK [{rnn_tx_id}]: Iniciando estratégia de investimento para cliente {client_id}, valor {amount}.")
+    transactions_db[rnn_tx_id]["status"] = "processing"
+    transactions_db[rnn_tx_id]["status_details"] = "Initializing investment cycle"
+    
+    final_status = "completed"
+    error_details = "" # Acumula mensagens de erro de várias etapas
+    calculated_final_amount = amount 
+
+    # Inicializa a exchange ccxt usando o utilitário
+    # O logger do app.py é passado para ccxt_utils para que os logs apareçam no mesmo stream
+    exchange = await get_ccxt_exchange(logger_instance=logger) # MODIFICADO
+
+    if not exchange:
+        # get_ccxt_exchange já loga o erro. Se a exchange é crucial, podemos falhar aqui.
+        logger.warning(f"BG TASK [{rnn_tx_id}]: Falha ao inicializar a exchange. A estratégia pode não funcionar como esperado para cripto.")
+        # Se as chaves CCXT foram fornecidas no ambiente mas a exchange falhou, considere isso um erro de config.
+        if os.environ.get("CCXT_API_KEY") and os.environ.get("CCXT_API_SECRET"):
+            error_details += "Failed to initialize CCXT exchange despite API keys being present; "
+            final_status = "failed_config" 
+            # (PULAR PARA CALLBACK - veja a seção de tratamento de erro crítico abaixo)
+    
+    # =========================================================================
+    # 1. COLETAR DADOS DE MERCADO
+    # =========================================================================
+    logger.info(f"BG TASK [{rnn_tx_id}]: Coletando dados de mercado...")
+    transactions_db[rnn_tx_id]["status_details"] = "Fetching market data"
+    market_data_results = {"crypto": {}, "stocks": {}, "other": {}}
+    critical_data_fetch_failed = False # Flag para falha crítica na coleta de dados
+
+    # --- Coleta de dados de Cripto via ccxt_utils ---
+    if exchange:
+        crypto_pairs_to_fetch = ["BTC/USDT", "ETH/USDT", "SOL/USDT"] # Mantenha configurável
+        
+        crypto_data, crypto_fetch_ok, crypto_err_msg = await fetch_crypto_data(
+            exchange, 
+            crypto_pairs_to_fetch, 
+            logger_instance=logger
+        )
+        market_data_results["crypto"] = crypto_data
+        if not crypto_fetch_ok:
+            error_details += f"Crypto data fetch issues: {crypto_err_msg}; "
+            # Decida se a falha na coleta de cripto é crítica
+            # Se for, defina critical_data_fetch_failed = True
+            if os.environ.get("CCXT_API_KEY"): # Se esperávamos dados de cripto
+                critical_data_fetch_failed = True 
+                logger.error(f"BG TASK [{rnn_tx_id}]: Falha crítica na coleta de dados de cripto.")
+    else:
+        logger.info(f"BG TASK [{rnn_tx_id}]: Instância da exchange ccxt não disponível. Pulando coleta de dados de cripto.")
+        if os.environ.get("CCXT_API_KEY"): # Se esperávamos dados de cripto mas a exchange não inicializou
+            error_details += "CCXT exchange not initialized, crypto data skipped; "
+            critical_data_fetch_failed = True
+
+
+    # --- Coleta de dados para outros tipos de ativos (ex: Ações com yfinance) ---
+    # (Sua lógica yfinance aqui, se aplicável, similarmente atualizando market_data_results["stocks"])
+    # try:
+    #     import yfinance as yf # Mova para o topo do app.py se for usar
+    #     # ... lógica yfinance ...
+    # except Exception as e_yf:
+    #     logger.warning(f"BG TASK [{rnn_tx_id}]: Falha ao buscar dados de ações com yfinance: {e_yf}")
+    #     error_details += f"YFinance data fetch failed: {str(e_yf)}; "
+    #     # Decida se isso é crítico: critical_data_fetch_failed = True
+
+    market_data_results["other"]['simulated_index_level'] = random.uniform(10000, 15000) # Mantém simulação
+    
+    transactions_db[rnn_tx_id]["market_data_collected"] = market_data_results
+    
+    # --- PONTO DE CHECAGEM PARA FALHA CRÍTICA NA COLETA DE DADOS ---
+    if critical_data_fetch_failed:
+        final_status = "failed_market_data"
+        logger.error(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado falhou criticamente. {error_details}")
+        # Pular para a seção de callback
+        # (A lógica de envio do callback precisa ser alcançada)
+    else:
+        logger.info(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado concluída.")
+        transactions_db[rnn_tx_id]["status_details"] = "Processing RNN analysis"
+
+
+
+
+
+    # =========================================================================
+    # 2. ANÁLISE PELA RNN E TOMADA DE DECISÃO
+    # =========================================================================
+    investment_decisions: List[Dict[str, Any]] = [] 
+    total_usd_allocated_by_rnn = 0.0
+    loop = asyncio.get_running_loop() 
+
+    if final_status == "completed": 
+        logger.info(f"BG TASK [{rnn_tx_id}]: Executando análise RNN...")
+        transactions_db[rnn_tx_id]["status_details"] = "Running RNN model"
+        rnn_analysis_success = True
+        
+        # CORRIGIDO: Acessando app.state.rnn_predictor
+        predictor: Optional[RNNModelPredictor] = getattr(app.state, 'rnn_predictor', None)
+
+        try:
+                crypto_data_for_rnn = market_data_results.get("crypto", {})
+                candidate_assets = [
+                    asset_key for asset_key, data in crypto_data_for_rnn.items() 
+                    if data and not data.get("error") and data.get("ohlcv_1h") # Apenas com dados válidos
+                ]
+                
+                # --- Parâmetros de Gerenciamento de Risco e Alocação (AJUSTE FINO É CRUCIAL) ---
+                # Risco total do portfólio para este ciclo (ex: não usar mais que 50% do capital total em novas posições)
+                MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE = 0.75 # Usar até 75% do 'amount'
+                
+                # Risco por ativo individual (percentual do 'amount' TOTAL)
+                MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL = 0.15 # Ex: máx 15% do capital total em UM ativo
+                MIN_ALLOCATION_PER_ASSET_PCT_OF_TOTAL = 0.02 # Ex: mín 2% do capital total para valer a pena
+
+                MIN_USD_PER_ORDER = 25.00     # Mínimo de USD por ordem
+                MAX_CONCURRENT_POSITIONS = 4  # Máximo de posições abertas simultaneamente
+                
+                # Limiares de Confiança da RNN
+                CONFIDENCE_STRONG_BUY = 0.80 # Confiança para considerar uma alocação maior
+                CONFIDENCE_MODERATE_BUY = 0.65 # Confiança mínima para considerar uma alocação base
+                CONFIDENCE_WEAK_BUY = 0.55    # Confiança para uma alocação muito pequena ou nenhuma
+
+                allocated_capital_this_cycle = 0.0
+                
+                # Para diversificação, podemos querer limitar a avaliação ou dar pesos
+                # random.shuffle(candidate_assets) 
+
+                for asset_key in candidate_assets:
+                    if len(investment_decisions) >= MAX_CONCURRENT_POSITIONS:
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de {MAX_CONCURRENT_POSITIONS} posições concorrentes atingido.")
+                        break
+                    
+                    # Verifica se já usamos o capital máximo para o ciclo
+                    if allocated_capital_this_cycle >= amount * MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE:
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de capital para o ciclo ({MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE*100}%) atingido.")
+                        break
+
+                    asset_symbol = asset_key.replace("_", "/")
+                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN avaliando ativo: {asset_symbol}")
+                    
+                    signal, confidence_prob = await predictor.predict_for_asset(
+                        crypto_data_for_rnn[asset_key], 
+                        loop=loop
+                    )
+
+                    if signal == 1 and confidence_prob is not None: # Sinal de COMPRA e confiança válida
+                        target_usd_allocation = 0.0
+
+                        if confidence_prob >= CONFIDENCE_STRONG_BUY:
+                            # Alocação maior para sinais fortes
+                            # Ex: entre 60% e 100% da alocação máxima permitida por ativo
+                            alloc_factor = 0.6 + 0.4 * ((confidence_prob - CONFIDENCE_STRONG_BUY) / (1.0 - CONFIDENCE_STRONG_BUY + 1e-6))
+                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
+                            reason = f"RNN STRONG BUY signal (Conf: {confidence_prob:.3f})"
+                        elif confidence_prob >= CONFIDENCE_MODERATE_BUY:
+                            # Alocação base para sinais moderados
+                            # Ex: entre 30% e 60% da alocação máxima permitida por ativo
+                            alloc_factor = 0.3 + 0.3 * ((confidence_prob - CONFIDENCE_MODERATE_BUY) / (CONFIDENCE_STRONG_BUY - CONFIDENCE_MODERATE_BUY + 1e-6))
+                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
+                            reason = f"RNN MODERATE BUY signal (Conf: {confidence_prob:.3f})"
+                        elif confidence_prob >= CONFIDENCE_WEAK_BUY:
+                             # Alocação pequena para sinais fracos (ou nenhuma)
+                            alloc_factor = 0.1 + 0.2 * ((confidence_prob - CONFIDENCE_WEAK_BUY) / (CONFIDENCE_MODERATE_BUY - CONFIDENCE_WEAK_BUY + 1e-6))
+                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
+                            reason = f"RNN WEAK BUY signal (Conf: {confidence_prob:.3f})"
+                        else:
+                            logger.info(f"BG TASK [{rnn_tx_id}]: Sinal COMPRA para {asset_symbol} mas confiança ({confidence_prob:.3f}) abaixo do limiar WEAK_BUY ({CONFIDENCE_WEAK_BUY}). Pulando.")
+                            continue
+                        
+                        # Garantir que a alocação não seja menor que a mínima permitida (percentual do total)
+                        target_usd_allocation = max(target_usd_allocation, amount * MIN_ALLOCATION_PER_ASSET_PCT_OF_TOTAL)
+
+                        # Garantir que não exceda o capital restante disponível neste CICLO
+                        capital_left_for_this_cycle = (amount * MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE) - allocated_capital_this_cycle
+                        actual_usd_allocation = min(target_usd_allocation, capital_left_for_this_cycle)
+                        
+                        # Garantir que a ordem mínima em USD seja respeitada
+                        if actual_usd_allocation < MIN_USD_PER_ORDER:
+                            logger.info(f"BG TASK [{rnn_tx_id}]: Alocação final ({actual_usd_allocation:.2f}) para {asset_symbol} abaixo do mínimo de ordem ({MIN_USD_PER_ORDER}). Pulando.")
+                            continue
+                        
+                        # Adicionar à lista de decisões
+                        investment_decisions.append({
+                            "asset_id": asset_symbol, "type": "CRYPTO", "action": "BUY",
+                            "target_usd_amount": round(actual_usd_allocation, 2),
+                            "rnn_confidence": round(confidence_prob, 4),
+                            "reasoning": reason
+                        })
+                        allocated_capital_this_cycle += round(actual_usd_allocation, 2)
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Decisão: COMPRAR {actual_usd_allocation:.2f} USD de {asset_symbol}. {reason}")
+                    
+                    # ... (restante da lógica para signal 0 ou None) ...
+        except Exception as e: # Captura exceções da lógica da RNN
+                logger.error(f"BG TASK [{rnn_tx_id}]: Erro CRÍTICO durante análise/predição RNN: {str(e)}", exc_info=True)
+                rnn_analysis_success = False # Marca que a análise RNN falhou
+                error_details += f"Critical RNN analysis/prediction error: {str(e)}; "
+
+
+        total_usd_allocated_by_rnn = allocated_capital_this_cycle 
+      
+      
+        
+
+        if not predictor or not predictor.model: # Verifica se o preditor e o modelo interno existem
+            logger.warning(f"BG TASK [{rnn_tx_id}]: Instância do preditor RNN não disponível ou modelo interno não carregado. Pulando análise RNN.")
+            rnn_analysis_success = False 
+            error_details += "RNN model/predictor not available for prediction; "
+        else:
+            try:
+                # ... (lógica de iteração sobre `candidate_assets` e chamada a `predictor.predict_for_asset` como na resposta anterior)
+                # ... (lógica de alocação de capital como na resposta anterior)
+                # Garantir que toda essa lógica está dentro deste bloco 'else'
+                crypto_data_for_rnn = market_data_results.get("crypto", {})
+                candidate_assets = [
+                    asset_key for asset_key, data in crypto_data_for_rnn.items() 
+                    if data and not data.get("error") and data.get("ohlcv_1h")
+                ]
+                
+                MAX_RISK_PER_ASSET_PCT = 0.05 
+                MIN_USD_PER_ORDER = 20.00    
+                MAX_CONCURRENT_POSITIONS = 5 
+                CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC = 0.85 
+                CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC = 0.60 
+                BASE_ALLOCATION_PCT_OF_TOTAL_CAPITAL = 0.10 
+
+                allocated_capital_this_cycle = 0.0
+                
+                for asset_key in candidate_assets:
+                    if len(investment_decisions) >= MAX_CONCURRENT_POSITIONS:
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de posições concorrentes ({MAX_CONCURRENT_POSITIONS}) atingido.")
+                        break
+                    if allocated_capital_this_cycle >= amount * 0.90:
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de capital do ciclo atingido.")
+                        break
+
+                    asset_symbol = asset_key.replace("_", "/")
+                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN avaliando ativo: {asset_symbol}")
+                    
+                    signal, confidence_prob = await predictor.predict_for_asset(
+                        crypto_data_for_rnn[asset_key], 
+                        loop=loop
+                        # window_size e expected_features serão os defaults de rnn_predictor.py
+                        # ou podem ser passados explicitamente se você quiser variar por ativo
+                    )
+
+                    if signal == 1: 
+                        if confidence_prob is None or confidence_prob < CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC:
+                            logger.info(f"BG TASK [{rnn_tx_id}]: Sinal COMPRA para {asset_symbol} mas confiança ({confidence_prob}) abaixo do mínimo {CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC}. Pulando.")
+                            continue
+
+                        confidence_factor = 0.5 
+                        if confidence_prob >= CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC:
+                            confidence_factor = 1.0
+                        elif confidence_prob > CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC: 
+                            confidence_factor = 0.5 + 0.5 * (
+                                (confidence_prob - CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC) /
+                                (CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC - CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC)
+                            )
+                        
+                        potential_usd_allocation = amount * BASE_ALLOCATION_PCT_OF_TOTAL_CAPITAL * confidence_factor
+                        potential_usd_allocation = min(potential_usd_allocation, amount * MAX_RISK_PER_ASSET_PCT)
+                        remaining_capital_for_cycle = amount - allocated_capital_this_cycle # Recalcula a cada iteração
+                        actual_usd_allocation = min(potential_usd_allocation, remaining_capital_for_cycle)
+
+                        if actual_usd_allocation < MIN_USD_PER_ORDER:
+                            logger.info(f"BG TASK [{rnn_tx_id}]: Alocação calculada ({actual_usd_allocation:.2f}) para {asset_symbol} abaixo do mínimo ({MIN_USD_PER_ORDER}). Pulando.")
+                            continue
+                        
+                        investment_decisions.append({
+                            "asset_id": asset_symbol, "type": "CRYPTO", "action": "BUY",
+                            "target_usd_amount": round(actual_usd_allocation, 2),
+                            "rnn_confidence": round(confidence_prob, 4) if confidence_prob is not None else None,
+                            "reasoning": f"RNN signal BUY for {asset_symbol} with confidence {confidence_prob:.2f}"
+                        })
+                        allocated_capital_this_cycle += round(actual_usd_allocation, 2)
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Decisão: COMPRAR {actual_usd_allocation:.2f} USD de {asset_symbol} (Conf: {confidence_prob:.2f})")
+                    
+                    elif signal == 0: 
+                        logger.info(f"BG TASK [{rnn_tx_id}]: RNN sinal NÃO COMPRAR para {asset_symbol} (Conf: {confidence_prob:.2f if confidence_prob is not None else 'N/A'})")
+                    else: 
+                        logger.warning(f"BG TASK [{rnn_tx_id}]: RNN não gerou sinal para {asset_symbol}.")
+                
+                if not investment_decisions:
+                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN não gerou decisões de COMPRA válidas após avaliação e alocação.")
+            
+            except Exception as e: # Captura exceções da lógica da RNN
+                logger.error(f"BG TASK [{rnn_tx_id}]: Erro CRÍTICO durante análise/predição RNN: {str(e)}", exc_info=True)
+                rnn_analysis_success = False # Marca que a análise RNN falhou
+                error_details += f"Critical RNN analysis/prediction error: {str(e)}; "
+        
+        if not rnn_analysis_success: # Se a flag foi setada para False
+            final_status = "failed_rnn_analysis" 
+        
+        transactions_db[rnn_tx_id]["rnn_decisions"] = investment_decisions
+    
+    total_usd_allocated_by_rnn = allocated_capital_this_cycle 
+    transactions_db[rnn_tx_id]["status_details"] = "Preparing to execute orders"
+
+   
+   
+
+
+
+
+
+
+
+    # =========================================================================
+    # 3. EXECUÇÃO DE ORDENS (Só executa se a RNN não falhou e gerou ordens)
+    # =========================================================================
+    executed_trades_info: List[Dict[str, Any]] = []
+    current_portfolio_value = 0.0 # Valor dos ativos comprados, baseado no custo
+    cash_remaining_after_execution = amount # Começa com todo o montante
+    
+    if final_status == "completed" and investment_decisions and exchange:
+        logger.info(f"BG TASK [{rnn_tx_id}]: Executando {len(investment_decisions)} ordens...")
+        transactions_db[rnn_tx_id]["status_details"] = "Executing investment orders"
+        order_execution_overall_success = True
+
+        # Placeholder para LÓGICA REAL DE EXECUÇÃO DE ORDENS (CREATE_ORDER_PLACEHOLDER)
+        # Esta seção precisa ser preenchida com:
+        # 1. Iterar sobre `investment_decisions`.
+        # 2. Para cada decisão de "BUY":
+        #    a. Determinar o símbolo correto na exchange (ex: "BTC/USDT").
+        #    b. Obter o preço atual (ticker) para calcular a quantidade de ativo a comprar.
+        #       `amount_of_asset = target_usd_amount / current_price_of_asset`
+        #    c. Considerar saldo disponível na exchange (se estiver gerenciando isso).
+        #    d. Criar a ordem via `await exchange.create_market_buy_order(symbol, amount_of_asset)`
+        #       ou `create_limit_buy_order(symbol, amount_of_asset, limit_price)`.
+        #       Para ordens limite, a RNN precisaria fornecer o `limit_price`.
+        #    e. Tratar respostas da exchange (sucesso, falha, ID da ordem).
+        #       `ccxt.InsufficientFunds`, `ccxt.InvalidOrder`, etc.
+        #    f. Armazenar detalhes da ordem em `executed_trades_info`:
+        #       { "asset_id": ..., "order_id_exchange": ..., "type": "market/limit", "side": "buy",
+        #         "requested_usd_amount": ..., "asset_quantity_ordered": ..., 
+        #         "status_from_exchange": ..., "filled_quantity": ..., "average_fill_price": ...,
+        #         "cost_in_usd": ..., "fees_paid": ..., "timestamp": ... }
+        #    g. Atualizar `current_portfolio_value` com o `cost_in_usd` da ordem preenchida.
+        #    h. Deduzir `cost_in_usd` de `cash_remaining_after_execution`.
+        # 3. Para decisões de "SELL" (se sua RNN gerar):
+        #    a. Verificar se você possui o ativo (requer gerenciamento de portfólio).
+        #    b. Criar ordem de venda.
+        #    c. Atualizar `current_portfolio_value` e `cash_remaining_after_execution`.
+
+        # Simulação atual:
+        for decision in investment_decisions:
+            if decision.get("action") == "BUY" and decision.get("type") == "CRYPTO":
+                asset_symbol = decision["asset_id"]
+                usd_to_spend = decision["target_usd_amount"]
+                
+                # Simular pequena chance de falha na ordem
+                if random.random() < 0.05:
+                    logger.warning(f"BG TASK [{rnn_tx_id}]: Falha simulada ao executar ordem para {asset_symbol}.")
+                    executed_trades_info.append({
+                        "asset_id": asset_symbol, "status": "failed_simulated", 
+                        "requested_usd_amount": usd_to_spend, "error": "Simulated exchange rejection"
+                    })
+                    order_execution_overall_success = False # Marca que pelo menos uma falhou
+                    continue # Pula para a próxima decisão
+
+                # Simular slippage e custo
+                simulated_cost = usd_to_spend * random.uniform(0.995, 1.005) # +/- 0.5% slippage
+                
+                # Garantir que não estamos gastando mais do que o caixa restante
+                if simulated_cost > cash_remaining_after_execution:
+                    simulated_cost = cash_remaining_after_execution # Gasta apenas o que tem
+                    if simulated_cost < 1: # Se não há quase nada, não faz a ordem
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Saldo insuficiente ({cash_remaining_after_execution:.2f}) para ordem de {asset_symbol}, pulando.")
+                        continue
+
+
+                if simulated_cost > 0:
+                    current_portfolio_value += simulated_cost
+                    cash_remaining_after_execution -= simulated_cost
+                    executed_trades_info.append({
+                        "asset_id": asset_symbol, "order_id_exchange": f"sim_ord_{uuid.uuid4()}",
+                        "type": "market", "side": "buy",
+                        "requested_usd_amount": usd_to_spend,
+                        "status_from_exchange": "filled", "cost_in_usd": round(simulated_cost, 2),
+                        "timestamp": datetime.utcnow().isoformat()
+                    })
+                    logger.info(f"BG TASK [{rnn_tx_id}]: Ordem simulada para {asset_symbol} (custo: {simulated_cost:.2f} USD) preenchida.")
+        
+        await asyncio.sleep(random.uniform(1, 2) * len(investment_decisions) if investment_decisions else 1)
+
+        if not order_execution_overall_success:
+            error_details += "One or more orders failed during execution; "
+            # Decida se isso torna o status final 'failed_order_execution' ou se 'completed_with_partial_failure'
+            # final_status = "completed_with_partial_failure" # Exemplo de um novo status
+    
+    elif not exchange and investment_decisions:
+        logger.warning(f"BG TASK [{rnn_tx_id}]: Decisões de investimento geradas, mas a exchange não está disponível para execução.")
+        error_details += "Exchange not available for order execution; "
+        final_status = "failed_order_execution" # Se a execução é crítica
+        cash_remaining_after_execution = amount # Nada foi gasto
+    
+    transactions_db[rnn_tx_id]["executed_trades"] = executed_trades_info
+    transactions_db[rnn_tx_id]["cash_after_execution"] = round(cash_remaining_after_execution, 2)
+    transactions_db[rnn_tx_id]["portfolio_value_after_execution"] = round(current_portfolio_value, 2)
+    
+
+    # =========================================================================
+    # 4. SIMULAÇÃO DO PERÍODO DE INVESTIMENTO E CÁLCULO DE LUCRO/PERDA (Só se não houve falha crítica antes)
+    # =========================================================================
+    value_of_investments_at_eod = current_portfolio_value # Começa com o valor de custo
+
+    if final_status == "completed": # Ou "completed_with_partial_failure"
+        transactions_db[rnn_tx_id]["status_details"] = "Simulating EOD valuation"
+        logger.info(f"BG TASK [{rnn_tx_id}]: Simulando valorização do portfólio no final do dia...")
+        await asyncio.sleep(random.uniform(3, 7)) 
+
+        if current_portfolio_value > 0:
+            # Simular mudança de valor do portfólio. A meta de 4.2% é sobre o capital INVESTIDO.
+            # O lucro/perda é aplicado ao `current_portfolio_value` (o que foi efetivamente comprado).
+            daily_return_factor = 0.042 # A meta
+            simulated_performance_factor = random.uniform(0.7, 1.3) # Variação em torno da meta (pode ser prejuízo)
+            # Para ser mais realista, o fator de performance deveria ser algo como:
+            # random.uniform(-0.05, 0.08) -> -5% a +8% de retorno diário sobre o investido (ainda alto)
+            # E não diretamente ligado à meta de 4.2%
+            
+            # Ajuste para uma simulação de retorno mais plausível (ainda agressiva)
+            # Suponha que o retorno diário real possa variar de -3% a +5% sobre o investido
+            actual_daily_return_on_portfolio = random.uniform(-0.03, 0.05) 
+            
+            profit_or_loss_on_portfolio = current_portfolio_value * actual_daily_return_on_portfolio
+            value_of_investments_at_eod = current_portfolio_value + profit_or_loss_on_portfolio
+            logger.info(f"BG TASK [{rnn_tx_id}]: Portfólio inicial: {current_portfolio_value:.2f}, Retorno simulado: {actual_daily_return_on_portfolio*100:.2f}%, "
+                        f"Lucro/Prejuízo no portfólio: {profit_or_loss_on_portfolio:.2f}, Valor EOD do portfólio: {value_of_investments_at_eod:.2f}")
+        else: 
+            logger.info(f"BG TASK [{rnn_tx_id}]: Nenhum portfólio para valorizar no EOD (nada foi comprado).")
+            value_of_investments_at_eod = 0.0
+        
+        # O calculated_final_amount é o valor dos investimentos liquidados + o caixa que não foi usado
+        calculated_final_amount = value_of_investments_at_eod + cash_remaining_after_execution
+    
+    else: # Se houve falha antes, o valor final é o que sobrou após a falha
+        calculated_final_amount = cash_remaining_after_execution + current_portfolio_value # current_portfolio_value pode ser 0 ou parcial
+        logger.warning(f"BG TASK [{rnn_tx_id}]: Ciclo de investimento não concluído normalmente ({final_status}). Valor final baseado no estado atual.")
+
+    transactions_db[rnn_tx_id]["eod_portfolio_value_simulated"] = round(value_of_investments_at_eod, 2)
+    transactions_db[rnn_tx_id]["final_calculated_amount"] = round(calculated_final_amount, 2)
+
+
+    # =========================================================================
+    # 5. TOKENIZAÇÃO / REGISTRO DA OPERAÇÃO (Só se não houve falha crítica antes)
+    # =========================================================================
+    if final_status not in ["failed_config", "failed_market_data", "failed_rnn_analysis"]: # Prossegue se ao menos tentou executar
+        transactions_db[rnn_tx_id]["status_details"] = "Finalizing transaction log (tokenization)"
+        logger.info(f"BG TASK [{rnn_tx_id}]: Registrando (tokenizando) operação detalhadamente...")
+        # Placeholder para LÓGICA REAL DE TOKENIZAÇÃO (TOKENIZATION_PLACEHOLDER)
+        # 1. Coletar todos os dados relevantes da transação de `transactions_db[rnn_tx_id]`
+        #    (market_data_collected, rnn_decisions, executed_trades, eod_portfolio_value_simulated, etc.)
+        # 2. Se for usar blockchain:
+        #    a. Preparar os dados para um contrato inteligente.
+        #    b. Interagir com o contrato (ex: web3.py para Ethereum).
+        #    c. Armazenar o hash da transação da blockchain.
+        # 3. Se for um registro interno avançado:
+        #    a. Assinar digitalmente os dados da transação.
+        #    b. Armazenar em um sistema de log imutável ou banco de dados com auditoria.
+        
+        # Simulação atual (hash dos dados da transação):
+        transaction_data_for_hash = {
+            "rnn_tx_id": rnn_tx_id, "client_id": client_id, "initial_amount": amount,
+            "final_amount_calculated": calculated_final_amount,
+            # Incluir resumos ou hashes dos dados coletados para não tornar o hash gigante
+            "market_data_summary_keys": list(transactions_db[rnn_tx_id].get("market_data_collected", {}).keys()),
+            "rnn_decisions_count": len(transactions_db[rnn_tx_id].get("rnn_decisions", [])),
+            "executed_trades_count": len(transactions_db[rnn_tx_id].get("executed_trades", [])),
+            "eod_portfolio_value": transactions_db[rnn_tx_id].get("eod_portfolio_value_simulated"),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        ordered_tx_data_str = json.dumps(transaction_data_for_hash, sort_keys=True)
+        proof_token_hash = hashlib.sha256(ordered_tx_data_str.encode('utf-8')).hexdigest()
+        
+        transactions_db[rnn_tx_id]["proof_of_operation_token"] = proof_token_hash
+        transactions_db[rnn_tx_id]["tokenization_method"] = "internal_summary_hash_proof"
+        await asyncio.sleep(0.5) # Simula tempo de escrita/hash
+        logger.info(f"BG TASK [{rnn_tx_id}]: Operação registrada. Prova (hash): {proof_token_hash[:10]}...")
+
+
+    # =========================================================================
+    # 6. PREPARAR E ENVIAR CALLBACK PARA AIBANK
+    # =========================================================================
+    if exchange and hasattr(exchange, 'close'):
+        try:
+            await exchange.close()
+            logger.info(f"BG TASK [{rnn_tx_id}]: Conexão ccxt fechada.")
+        except Exception as e_close: # Especificar o tipo de exceção se souber
+            logger.warning(f"BG TASK [{rnn_tx_id}]: Erro ao fechar conexão ccxt: {str(e_close)}")
+
+    if not AIBANK_CALLBACK_URL or not CALLBACK_SHARED_SECRET:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Configuração de callback ausente. Não é possível notificar o AIBank.")
+        transactions_db[rnn_tx_id]["callback_status"] = "config_missing_critical"
+        return 
+
+    # Certifique-se que `final_status` reflete o estado real da operação
+    # Se `error_details` não estiver vazio e `final_status` ainda for "completed", ajuste-o
+    if error_details and final_status == "completed":
+        final_status = "completed_with_warnings" # Ou um status mais apropriado
+
+    callback_payload_data = InvestmentResultPayload(
+        rnn_transaction_id=rnn_tx_id, aibank_transaction_token=aibank_tx_token, client_id=client_id,
+        initial_amount=amount, final_amount=round(calculated_final_amount, 2), # Arredonda para 2 casas decimais
+        profit_loss=round(calculated_final_amount - amount, 2),
+        status=final_status, timestamp=datetime.utcnow(),
+        details=error_details if error_details else "Investment cycle processed."
+    )
+    payload_json_str = callback_payload_data.model_dump_json() # Garante que está usando a string serializada
+    
+    signature = hmac.new(CALLBACK_SHARED_SECRET.encode('utf-8'), payload_json_str.encode('utf-8'), hashlib.sha256).hexdigest()
+    headers = {'Content-Type': 'application/json', 'X-RNN-Signature': signature}
+
+    logger.info(f"BG TASK [{rnn_tx_id}]: Enviando callback para AIBank ({AIBANK_CALLBACK_URL}) com status final '{final_status}'. Payload: {payload_json_str}")
+    transactions_db[rnn_tx_id]["callback_status"] = "sending"
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client: # Timeout global para o cliente
+            response = await client.post(AIBANK_CALLBACK_URL, content=payload_json_str, headers=headers)
+            response.raise_for_status()
+            logger.info(f"BG TASK [{rnn_tx_id}]: Callback para AIBank enviado com sucesso. Resposta: {response.status_code}")
+            transactions_db[rnn_tx_id]["callback_status"] = f"sent_success_{response.status_code}"
+    except httpx.RequestError as e_req:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro de REDE ao enviar callback para AIBank: {e_req}")
+        transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_network_error"
+    except httpx.HTTPStatusError as e_http:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro HTTP do AIBank ao receber callback: {e_http.response.status_code} - {e_http.response.text[:200]}")
+        transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_http_error_{e_http.response.status_code}"
+    except Exception as e_cb_final:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro INESPERADO ao enviar callback: {e_cb_final}", exc_info=True)
+        transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_unknown_error"
+
+
+import asyncio 
+import random  
+
+    
+
+# --- Endpoints da API ---
+@app.post("/api/invest",
+          response_model=InvestmentResponse,
+          dependencies=[Depends(verify_aibank_key)])
+async def initiate_investment(
+    request_data: InvestmentRequest,
+    background_tasks: BackgroundTasks
+):
+    """
+    Endpoint para o AIBank iniciar um ciclo de investimento.
+    Responde rapidamente e executa a lógica pesada em background.
+    """
+    logger.info(f"Requisição de investimento recebida para client_id: {request_data.client_id}, "
+                f"amount: {request_data.amount}, aibank_tx_token: {request_data.aibank_transaction_token}")
+
+    rnn_tx_id = str(uuid.uuid4())
+
+    # Armazena informações iniciais da transação DB real para ser mais robusto
+    transactions_db[rnn_tx_id] = {
+        "rnn_transaction_id": rnn_tx_id,
+        "aibank_transaction_token": request_data.aibank_transaction_token,
+        "client_id": request_data.client_id,
+        "initial_amount": request_data.amount,
+        "status": "pending_background_processing",
+        "received_at": datetime.utcnow().isoformat(),
+        "callback_status": "not_sent_yet"
+    }
+
+    # Adiciona a tarefa de longa duração ao background
+    background_tasks.add_task(
+        execute_investment_strategy_background,
+        rnn_tx_id,
+        request_data.client_id,
+        request_data.amount,
+        request_data.aibank_transaction_token
+    )
+
+    logger.info(f"Estratégia de investimento para rnn_tx_id: {rnn_tx_id} agendada para execução em background.")
+    return InvestmentResponse(
+        status="pending",
+        message="Investment request received and is being processed in the background. Await callback for results.",
+        rnn_transaction_id=rnn_tx_id
+    )
+
+@app.get("/api/transaction_status/{rnn_tx_id}", response_class=JSONResponse)
+async def get_transaction_status(rnn_tx_id: str):
+    """ Endpoint para verificar o status de uma transação (para debug/admin) """
+    transaction = transactions_db.get(rnn_tx_id)
+    if not transaction:
+        raise HTTPException(status_code=404, detail="Transaction not found")
+    return transaction
+
+
+# --- Dashboard (Existente, adaptado) ---
+# Setup para arquivos estáticos e templates
+
+try:
+    app.mount("/static", StaticFiles(directory="rnn/static"), name="static")
+    templates = Environment(loader=FileSystemLoader("rnn/templates"))
+except RuntimeError as e:
+    logger.warning(f"Não foi possível montar /static ou carregar templates: {e}. O dashboard pode não funcionar.")
+    templates = None # Para evitar erros se o loader falhar
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    if not templates:
+        return HTMLResponse("<html><body><h1>Dashboard indisponível</h1><p>Configuração de templates/estáticos falhou.</p></body></html>")
+    
+    agora = datetime.now()
+    agentes_simulados = [
+        # dados de agentes ...
+    ]
+    template = templates.get_template("index.html")
+    # Adicionar transações recentes ao contexto do template
+    recent_txs = list(transactions_db.values())[-5:] # Últimas 5 transações
+    return HTMLResponse(template.render(request=request, agentes=agentes_simulados, transactions=recent_txs))
+
+# --- Imports para Background Task ---
+import asyncio
+import random
+
+# Função de logger dummy 
+# class DummyLogger:
+#     def info(self, msg, *args, **kwargs): print(f"INFO: {msg}")
+#     def warning(self, msg, *args, **kwargs): print(f"WARNING: {msg}")
+#     def error(self, msg, *args, **kwargs): print(f"ERROR: {msg}", kwargs.get('exc_info'))
+
+# if __name__ == "__main__": # Para teste local
+#     # logger = DummyLogger() # se não tiver get_logger()
+#     # Configuração das variáveis de ambiente para teste local
+#     os.environ["AIBANK_API_KEY"] = "test_aibank_key_from_rnn_server"
+#     os.environ["AIBANK_CALLBACK_URL"] = "http://localhost:8001/api/rnn_investment_result_callback" # URL do aibank simulado
+#     os.environ["CALLBACK_SHARED_SECRET"] = "super_secret_for_callback_signing"
+#     # import uvicorn
 #     # uvicorn.run(app, host="0.0.0.0", port=8000)