# rnn/app.py from agents.train_rl_portfolio_agent_from_app import model_ppo model_ppo() 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.utils.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_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("

Dashboard indisponível

Configuração de templates/estáticos falhou.

") 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)