Upload 120 files

AutomatedLendingPool.sol

@@ -0,0 +1,35 @@
+pragma solidity ^0.8.0;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./CreditOracle.sol";
+
+contract AutomatedLendingPool {
+    IERC20 public immutable token;
+    CreditOracle public immutable creditOracle;
+    
+    struct Loan {
+        uint256 amount;
+        uint256 interest;
+        uint256 dueDate;
+    }
+    
+    mapping(address => Loan) public loans;
+    
+    constructor(address _token, address _creditOracle) {
+        token = IERC20(_token);
+        creditOracle = CreditOracle(_creditOracle);
+    }
+    
+    function requestLoan(uint256 amount) external {
+        require(loans[msg.sender].amount == 0, "Existing loan must be repaid");
+        bytes32 requestId = creditOracle.requestCreditScore(msg.sender);
+        // Lógica para processar o empréstimo com base no score de crédito
+    }
+    
+    function repayLoan() external {
+        Loan storage loan = loans[msg.sender];
+        require(loan.amount > 0, "No active loan");
+        uint256 totalDue = loan.amount + loan.interest;
+        require(token.transferFrom(msg.sender, address(this), totalDue), "Transfer failed");
+        delete loans[msg.sender];
+    }
+}

CreditOracle.sol

@@ -0,0 +1,27 @@
+pragma solidity ^0.8.0;
+import "@chainlink/contracts/src/v0.8/ChainlinkClient.sol";
+
+contract CreditOracle is ChainlinkClient {
+    using Chainlink for Chainlink.Request;
+    
+    address private oracle;
+    bytes32 private jobId;
+    uint256 private fee;
+    
+    constructor() {
+        setPublicChainlinkToken();
+        oracle = 0x...;  // Endereço do nó Chainlink
+        jobId = "...";   // ID do job Chainlink
+        fee = 0.1 * 10 ** 18; // 0.1 LINK
+    }
+    
+    function requestCreditScore(address user) public returns (bytes32 requestId) {
+        Chainlink.Request memory request = buildChainlinkRequest(jobId, address(this), this.fulfill.selector);
+        request.add("userId", uint256(uint160(user)));
+        return sendChainlinkRequestTo(oracle, request, fee);
+    }
+    
+    function fulfill(bytes32 _requestId, uint256 _creditScore) public recordChainlinkFulfillment(_requestId) {
+        // Lógica para atualizar o score de crédito do usuário
+    }
+}

FuzzedDataProvider.js

@@ -0,0 +1,15 @@
+const { FuzzedDataProvider } = require('fuzzing-tools');
+
+function fuzzTest(data) {
+    const fuzz = new FuzzedDataProvider(data);
+    const amount = fuzz.consumeNumber();
+    const recipient = fuzz.consumeAddress();
+
+    try {
+        token.transfer(recipient, amount);
+    } catch (error) {
+        // Registrar e analisar erros
+    }
+}
+
+module.exports = { fuzzTest };

ImeAtcoinGovernance.sol

@@ -0,0 +1,59 @@
+pragma solidity ^0.8.0;
+import "@openzeppelin/contracts/governance/Governor.sol";
+import "@openzeppelin/contracts/governance/extensions/GovernorSettings.sol";
+import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
+import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
+import "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
+import "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";
+
+contract ImeAtcoinGovernance is Governor, GovernorSettings, GovernorCountingSimple, GovernorVotes, GovernorVotesQuorumFraction, GovernorTimelockControl {
+    constructor(IVotes _token, TimelockController _timelock)
+        Governor("ImeAtcoinGovernance")
+        GovernorSettings(1 /* 1 block */, 45818 /* 1 week */, 0)
+        GovernorVotes(_token)
+        GovernorVotesQuorumFraction(4)
+        GovernorTimelockControl(_timelock)
+    {}
+
+    function votingDelay() public view override(IGovernor, GovernorSettings) returns (uint256) {
+        return super.votingDelay();
+    }
+
+    function votingPeriod() public view override(IGovernor, GovernorSettings) returns (uint256) {
+        return super.votingPeriod();
+    }
+
+    function quorum(uint256 blockNumber) public view override(IGovernor, GovernorVotesQuorumFraction) returns (uint256) {
+        return super.quorum(blockNumber);
+    }
+
+    function state(uint256 proposalId) public view override(Governor, GovernorTimelockControl) returns (ProposalState) {
+        return super.state(proposalId);
+    }
+
+    function propose(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, string memory description)
+        public override(Governor, IGovernor) returns (uint256)
+    {
+        return super.propose(targets, values, calldatas, description);
+    }
+
+    function _execute(uint256 proposalId, address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)
+        internal override(Governor, GovernorTimelockControl)
+    {
+        super._execute(proposalId, targets, values, calldatas, descriptionHash);
+    }
+
+    function _cancel(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)
+        internal override(Governor, GovernorTimelockControl) returns (uint256)
+    {
+        return super._cancel(targets, values, calldatas, descriptionHash);
+    }
+
+    function _executor() internal view override(Governor, GovernorTimelockControl) returns (address) {
+        return super._executor();
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view override(Governor, GovernorTimelockControl) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+}

ImeAtcoinPayment.js

@@ -0,0 +1,15 @@
+class ImeAtcoinPayment {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+
+    async createPayment(amount, currency) {
+        // Lógica para criar um pagamento
+    }
+
+    async verifyPayment(paymentId) {
+        // Lógica para verificar um pagamento
+    }
+}
+
+module.exports = ImeAtcoinPayment;

MarketMaker.py

@@ -0,0 +1,30 @@
+import ccxt
+
+class MarketMaker:
+    def __init__(self, exchange, symbol, spread=0.01):
+        self.exchange = ccxt.exchange({'apiKey': '...', 'secret': '...'})
+        self.symbol = symbol
+        self.spread = spread
+
+    def place_orders(self):
+        ticker = self.exchange.fetch_ticker(self.symbol)
+        mid_price = (ticker['bid'] + ticker['ask']) / 2
+
+        bid_price = mid_price * (1 - self.spread / 2)
+        ask_price = mid_price * (1 + self.spread / 2)
+
+        self.exchange.create_limit_buy_order(self.symbol, 1, bid_price)
+        self.exchange.create_limit_sell_order(self.symbol, 1, ask_price)
+
+    def run(self):
+        while True:
+            try:
+                self.place_orders()
+                time.sleep(60)  # Atualiza ordens a cada minuto
+            except Exception as e:
+                print(f"Error: {e}")
+                time.sleep(60)
+
+if __name__ == "__main__":
+    market_maker = MarketMaker("binance", "I*****ME/USDT")
+    market_maker.run()

PrivateTransactions.sol

@@ -0,0 +1,23 @@
+pragma solidity ^0.8.0;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./ZkSnarkVerifier.sol";
+
+contract PrivateTransactions {
+    IERC20 public immutable token;
+    ZkSnarkVerifier public immutable verifier;
+
+    constructor(address _token, address _verifier) {
+        token = IERC20(_token);
+        verifier = ZkSnarkVerifier(_verifier);
+    }
+
+    function privateTransfer(
+        uint256[2] memory a,
+        uint256[2][2] memory b,
+        uint256[2] memory c,
+        uint256[3] memory input
+    ) external {
+        require(verifier.verifyProof(a, b, c, input), "Invalid zk-SNARK proof");
+        // Executar a transferência privada
+    }
+}

README.md

@@ -1,3 +1,12 @@
 ---
-license: mit
+title: Aibank Token
+emoji: 🐠
+colorFrom: yellow
+colorTo: pink
+sdk: static
+pinned: false
+license: other
+short_description: Token aibank
 ---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

RewardSystem.sol

@@ -0,0 +1,22 @@
+pragma solidity ^0.8.0;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract RewardSystem {
+    IERC20 public immutable token;
+    mapping(address => uint256) public rewards;
+
+    constructor(address _token) {
+        token = IERC20(_token);
+    }
+
+    function addReward(address user, uint256 amount) external {
+        rewards[user] += amount;
+    }
+
+    function claimReward() external {
+        uint256 amount = rewards[msg.sender];
+        require(amount > 0, "No rewards to claim");
+        rewards[msg.sender] = 0;
+        require(token.transfer(msg.sender, amount), "Transfer failed");
+    }
+}

agents/DeepPortfolioAgent.py

@@ -0,0 +1,361 @@
+
+# rnn/agents/deep_portfolio.py (ou onde você tem DeepPortfolioAI / DeepPortfolioAgentNetwork)
+import numpy as np
+from tensorflow.keras import regularizers
+import tensorflow as tf
+from tensorflow.keras.layers import (
+    Input, Conv1D, LSTM, Dense, Dropout, 
+    MultiHeadAttention, Reshape, Concatenate,
+    TimeDistributed, GlobalAveragePooling1D, LayerNormalization
+)
+from tensorflow.keras.models import Model
+from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
+# Comente as importações do transformers se não for testar o sentimento agora para simplificar
+# from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
+
+# --- DEFINIÇÕES DE CONFIGURAÇÃO (COPIE OU IMPORTE DO SEU CONFIG.PY) ---
+# Se você não importar do config.py, defina-as aqui para o teste
+WINDOW_SIZE_CONF = 60
+NUM_ASSETS_CONF = 4  # Ex: ETH, BTC, ADA, SOL
+NUM_FEATURES_PER_ASSET_CONF = 26 # Número de features calculadas para CADA ativo
+                                 # (open_div_atr, ..., buy_condition_v1, etc.)
+L2_REG = 0.0001 # Exemplo, use o valor do seu config
+
+# (Cole as classes AssetProcessor e DeepPortfolioAgentNetwork aqui se estiver em um novo script)
+# Ou, se estiver no mesmo arquivo, elas já estarão definidas.
+
+# ... (Definição das classes AssetProcessor e DeepPortfolioAgentNetwork como na resposta anterior) ...
+# Certifique-se que a classe DeepPortfolioAgentNetwork está usando estas constantes:
+# num_assets=NUM_ASSETS_CONF, 
+# sequence_length=WINDOW_SIZE_CONF, 
+# num_features_per_asset=NUM_FEATURES_PER_ASSET_CONF
+
+class AssetProcessor(tf.keras.Model):
+    def __init__(self, sequence_length, num_features, cnn_filters1=32, cnn_filters2=64, lstm_units1=64, lstm_units2=32, dropout_rate=0.2, name="single_asset_processor_module", **kwargs): # Adicionado **kwargs
+        super(AssetProcessor, self).__init__(name=name, **kwargs) # Adicionado **kwargs
+        self.sequence_length = sequence_length
+        self.num_features = num_features
+        self.cnn_filters1 = cnn_filters1 # Salvar para get_config
+        self.cnn_filters2 = cnn_filters2
+        self.lstm_units1 = lstm_units1
+        self.lstm_units2 = lstm_units2
+        self.dropout_rate = dropout_rate
+        
+        self.conv1 = Conv1D(filters=cnn_filters1, kernel_size=3, activation='relu', padding='same', name="asset_cnn1")
+        self.dropout_cnn1 = Dropout(dropout_rate, name="asset_cnn1_dropout")
+        self.conv2 = Conv1D(filters=cnn_filters2, kernel_size=3, activation='relu', padding='same', name="asset_cnn2")
+        self.dropout_cnn2 = Dropout(dropout_rate, name="asset_cnn2_dropout")
+        self.lstm1 = LSTM(lstm_units1, return_sequences=True, name="asset_lstm1")
+        self.dropout_lstm1 = Dropout(dropout_rate, name="asset_lstm1_dropout")
+        self.lstm2 = LSTM(lstm_units2, return_sequences=False, name="asset_lstm2_final")
+        self.dropout_lstm2 = Dropout(dropout_rate, name="asset_lstm2_dropout")
+
+    def call(self, inputs, training=False):
+        x = self.conv1(inputs)
+        x = self.dropout_cnn1(x, training=training)
+        x = self.conv2(x)
+        x = self.dropout_cnn2(x, training=training)
+        x = self.lstm1(x, training=training)
+        x = self.dropout_lstm1(x, training=training)
+        x = self.lstm2(x, training=training)
+        x_processed_asset = self.dropout_lstm2(x, training=training)
+        return x_processed_asset
+
+    def get_config(self):
+        config = super().get_config()
+        config.update({
+            "sequence_length": self.sequence_length,
+            "num_features": self.num_features,
+            "cnn_filters1": self.cnn_filters1,
+            "cnn_filters2": self.cnn_filters2,
+            "lstm_units1": self.lstm_units1,
+            "lstm_units2": self.lstm_units2,
+            "dropout_rate": self.dropout_rate,
+        })
+        return config
+
+class DeepPortfolioAgentNetwork(tf.keras.Model):
+    def __init__(self, 
+                 num_assets=int(NUM_ASSETS_CONF), 
+                 sequence_length=int(WINDOW_SIZE_CONF), 
+                 num_features_per_asset=int(NUM_FEATURES_PER_ASSET_CONF),
+                 asset_cnn_filters1=32, asset_cnn_filters2=64, 
+                 asset_lstm_units1=64, asset_lstm_units2=32, asset_dropout=0.2,
+                 mha_num_heads=4, mha_key_dim_divisor=2, # key_dim será asset_lstm_units2 // mha_key_dim_divisor
+                 final_dense_units1=128, final_dense_units2=64, final_dropout=0.3,
+                 use_sentiment_analysis=True, 
+                 output_latent_features=False, **kwargs): # Adicionado **kwargs
+        super(DeepPortfolioAgentNetwork, self).__init__(name="deep_portfolio_agent_network", **kwargs) # Adicionado **kwargs
+        
+
+        print(f"DPN __init__ > num_assets ENTRADA: {num_assets}, tipo: {type(num_assets)}")
+
+        # Tentar extrair o valor escalar se for um tensor/variável ou TrackedDict
+        def get_int_value(param_name, val):
+            if isinstance(val, (tf.Tensor, tf.Variable)):
+                if val.shape == tf.TensorShape([]): # Escalar
+                    print(f"DPN __init__: Convertendo {param_name} (Tensor/Variable escalar) para int.")
+                    return int(val.numpy())
+                else:
+                    raise ValueError(f"{param_name} é um Tensor/Variable mas não é escalar. Shape: {val.shape}")
+            elif isinstance(val, dict): # Pode ser um TrackedDict
+                # TrackedDict pode se comportar como um dict. Se o valor real está "escondido",
+                # precisamos descobrir como acessá-lo.
+                # Por agora, vamos tentar a conversão direta, e se falhar, o erro será mais claro.
+                # Se for um dict simples com uma chave específica, você precisaria dessa chave.
+                # O erro 'KeyError: value' sugere que ['value'] não é a forma correta.
+                # Geralmente, para hiperparâmetros, o TrackedDict deve conter o valor diretamente
+                # se o SB3 o passou corretamente.
+                print(f"DPN __init__: Tentando converter {param_name} (dict-like) para int.")
+                try:
+                    return int(val) # Tentar conversão direta
+                except TypeError:
+                     # Se TrackedDict se comporta como um tensor quando usado em ops TF,
+                     # tf.get_static_value pode funcionar, ou apenas o uso direto
+                     # em operações TF (mas range() não é uma op TF).
+                     # Se for um tensor TF "disfarçado", .numpy() pode funcionar.
+                     # Se for um dict com uma chave específica, essa chave seria necessária.
+                     # O erro mostra que ['value'] não funcionou.
+                     print(f"DPN __init__: Conversão direta de {param_name} (dict-like) para int falhou. Investigar TrackedDict.")
+                     # Para depuração, você pode tentar imprimir os itens do dict:
+                     # if isinstance(val, collections.abc.Mapping): # Checa se é um dict-like
+                     #    for k, v_item in val.items():
+                     #        print(f"   {param_name} item: {k} -> {v_item}")
+                     raise TypeError(f"{param_name} é {type(val)} e não pôde ser convertido para int diretamente. Valor: {val}")
+            else: # Tenta conversão direta para outros tipos
+                return int(val)
+
+        try:
+            self.num_assets = get_int_value("num_assets", num_assets)
+            self.sequence_length = get_int_value("sequence_length", sequence_length)
+            self.num_features_per_asset = get_int_value("num_features_per_asset", num_features_per_asset)
+            self.asset_lstm_output_dim = get_int_value("asset_lstm_units2", asset_lstm_units2) # Do kwargs
+            
+            # Faça o mesmo para TODOS os outros parâmetros que devem ser inteiros e são passados
+            # para construtores de camadas Keras (cnn_filters, lstm_units, mha_num_heads, etc.)
+            # Exemplo:
+            # self.asset_cnn_filters1_val = get_int_value("asset_cnn_filters1", kwargs.get("asset_cnn_filters1"))
+
+        except Exception as e_conv:
+            print(f"ERRO CRÍTICO DE CONVERSÃO DE TIPO no __init__ da DeepPortfolioAgentNetwork: {e_conv}")
+            raise
+
+        print(f"DPN __init__ > self.num_assets APÓS conversão: {self.num_assets}, tipo: {type(self.num_assets)}")
+        
+
+
+
+
+
+        self.num_assets = num_assets
+        self.sequence_length = sequence_length
+        self.num_features_per_asset = num_features_per_asset
+        self.asset_lstm_output_dim = asset_lstm_units2
+
+        self.asset_processor = AssetProcessor(
+            sequence_length=self.sequence_length, num_features=self.num_features_per_asset,
+            cnn_filters1=asset_cnn_filters1, cnn_filters2=asset_cnn_filters2,
+            lstm_units1=asset_lstm_units1, lstm_units2=asset_lstm_units2,
+            dropout_rate=asset_dropout
+        )
+        
+        # Ajustar key_dim para ser compatível com a dimensão de entrada e num_heads
+        # key_dim * num_heads deve ser idealmente igual a asset_lstm_output_dim se for auto-atenção direta,
+        # ou o MHA projeta internamente. Para simplificar, vamos fazer key_dim ser divisível.
+        # Se asset_lstm_output_dim não for divisível por num_heads, key_dim pode ser diferente.
+        # Vamos definir key_dim explicitamente. Se asset_lstm_output_dim = 32 e num_heads = 4, key_dim pode ser 8.
+        # Ou deixar o MHA lidar com a projeção se key_dim for diferente.
+        # Para maior clareza, calculamos uma key_dim sensata.
+        calculated_key_dim = self.asset_lstm_output_dim // mha_key_dim_divisor 
+        if calculated_key_dim == 0: # Evitar key_dim zero
+            calculated_key_dim = self.asset_lstm_output_dim # Fallback se for muito pequeno
+            print(f"AVISO: asset_lstm_output_dim ({self.asset_lstm_output_dim}) muito pequeno para mha_key_dim_divisor ({mha_key_dim_divisor}). Usando key_dim = {calculated_key_dim}")
+
+        self.attention = MultiHeadAttention(num_heads=mha_num_heads, key_dim=calculated_key_dim, dropout=0.1, name="multi_asset_attention")
+        self.attention_norm = LayerNormalization(epsilon=1e-6, name="attention_layernorm")
+        self.global_avg_pool_attention = GlobalAveragePooling1D(name="gap_after_attention")
+
+        self.use_sentiment = use_sentiment_analysis # Desabilitado por padrão para este teste
+        self.sentiment_embedding_size = 3 
+        if self.use_sentiment:
+            try:
+                self.tokenizer = AutoTokenizer.from_pretrained('ProsusAI/finbert')
+                self.sentiment_model = TFAutoModelForSequenceClassification.from_pretrained('ProsusAI/finbert', from_pt=True)
+                print("Modelo FinBERT carregado para análise de sentimento.")
+            except Exception as e:
+                print(f"AVISO: Falha ao carregar FinBERT: {e}. Análise de sentimento será desabilitada.")
+                self.use_sentiment = False
+
+        
+        dense_input_dim = self.use_sentiment
+        #if self.use_sentiment: dense_input_dim += self.sentiment_embedding_size
+        
+        self.dense1 = Dense(final_dense_units1, activation='relu', kernel_regularizer=regularizers.l2(L2_REG), name="final_dense1")
+        self.dropout1 = Dropout(final_dropout, name="final_dropout1")
+        self.dense2 = Dense(final_dense_units2, activation='relu', kernel_regularizer=regularizers.l2(L2_REG), name="final_dense2")
+        self.dropout2 = Dropout(final_dropout, name="final_dropout2")
+        self.output_allocation = Dense(self.num_assets, activation='softmax', name="portfolio_allocation_output")
+
+    def call(self, inputs, training=False):
+        market_data_flat = inputs 
+        
+        print(type(self.num_assets))
+        asset_representations_list = []
+        for i in range(self.num_assets):
+            start_idx = i * self.num_features_per_asset
+            end_idx = (i + 1) * self.num_features_per_asset
+            current_asset_data = market_data_flat[:, :, start_idx:end_idx]
+            processed_asset_representation = self.asset_processor(current_asset_data, training=training)
+            asset_representations_list.append(processed_asset_representation)
+            
+        stacked_asset_features = tf.stack(asset_representations_list, axis=1)
+        
+        # Para MHA, query, value, key são (batch_size, Tq, dim), (batch_size, Tv, dim)
+        # Aqui, T = num_assets, dim = asset_lstm_output_dim
+        attention_output = self.attention(
+            query=stacked_asset_features, value=stacked_asset_features, key=stacked_asset_features,
+            training=training
+        )
+        attention_output = self.attention_norm(stacked_asset_features + attention_output) 
+        
+        context_vector_from_attention = self.global_avg_pool_attention(attention_output)
+        
+        current_features_for_dense = context_vector_from_attention
+        # if self.use_sentiment: ... (lógica de concatenação)
+
+        x = self.dense1(current_features_for_dense)
+        x = self.dropout1(x, training=training)
+        x = self.dense2(x)
+        x = self.dropout2(x, training=training)
+        
+        portfolio_weights = self.output_allocation(x)
+        return portfolio_weights
+
+    def get_config(self): # Necessário se você quiser salvar/carregar o modelo que usa este sub-modelo
+        config = super().get_config()
+        config.update({
+            "num_assets": self.num_assets,
+            "sequence_length": self.sequence_length,
+            "num_features_per_asset": self.num_features_per_asset,
+            # Adicione outros args do __init__ aqui para todas as camadas e sub-modelos
+            "asset_lstm_output_dim": self.asset_lstm_output_dim,
+            # ... e os parâmetros passados para AssetProcessor e MHA, etc.
+        })
+        return config
+    
+    # @classmethod
+    # def from_config(cls, config): # Necessário para carregar com sub-modelo customizado
+    #    # Extrair config do AssetProcessor se necessário
+    #    return cls(**config)
+
+
+if __name__ == '__main__':
+    print("Testando o Forward Pass do DeepPortfolioAgentNetwork...")
+
+    # 1. Definir Parâmetros para o Teste (devem corresponder ao config.py)
+    batch_size_test = 2 # Um batch pequeno para teste
+    seq_len_test = WINDOW_SIZE_CONF
+    num_assets_test = NUM_ASSETS_CONF
+    num_features_per_asset_test = NUM_FEATURES_PER_ASSET_CONF
+    total_features_flat = num_assets_test * num_features_per_asset_test
+
+    print(f"Configuração do Teste:")
+    print(f"  Batch Size: {batch_size_test}")
+    print(f"  Sequence Length (Window): {seq_len_test}")
+    print(f"  Number of Assets: {num_assets_test}")
+    print(f"  Features per Asset: {num_features_per_asset_test}")
+    print(f"  Total Flat Features per Timestep: {total_features_flat}")
+
+    # 2. Criar Tensor de Input Mockado
+    # Shape: (batch_size, sequence_length, num_assets * num_features_per_asset)
+    mock_market_data_flat = tf.random.normal(
+        shape=(batch_size_test, seq_len_test, total_features_flat)
+    )
+    print(f"Shape do Input Mockado (market_data_flat): {mock_market_data_flat.shape}")
+
+    # 3. Instanciar o Modelo
+    # Use os mesmos hiperparâmetros que você definiria no config.py para a rede
+    print("\nInstanciando DeepPortfolioAgentNetwork...")
+    agent_network = DeepPortfolioAgentNetwork(
+        num_assets=num_assets_test,
+        sequence_length=seq_len_test,
+        num_features_per_asset=num_features_per_asset_test,
+        # Você pode variar os próximos parâmetros para testar diferentes configs
+        asset_cnn_filters1=32, asset_cnn_filters2=64,
+        asset_lstm_units1=64, asset_lstm_units2=32, # asset_lstm_units2 define asset_lstm_output_dim
+        asset_dropout=0.1,
+        mha_num_heads=4, mha_key_dim_divisor=4, # Ex: 32 // 4 = 8 para key_dim
+        final_dense_units1=64, final_dense_units2=32, final_dropout=0.2,
+        use_sentiment_analysis=False # Testar sem sentimento primeiro
+    )
+
+    # Para construir o modelo e ver o summary, você pode chamar com o input mockado
+    # ou explicitamente chamar model.build() se souber o input shape completo
+    # Chamar com input mockado é mais fácil para construir.
+    print("\nConstruindo o modelo com input mockado (primeira chamada)...")
+    try:
+        # É uma boa prática fazer a primeira chamada dentro de um tf.function para otimizar
+        # ou apenas chamar diretamente para teste.
+        _ = agent_network(mock_market_data_flat) # Chamada para construir as camadas
+        print("\n--- Summary da Rede Principal (DeepPortfolioAgentNetwork) ---")
+        agent_network.summary()
+        
+        # O summary do asset_processor já foi impresso no __init__ do DeepPortfolioAgentNetwork
+        # se você descomentar as linhas de build/summary lá.
+        # Ou você pode imprimir aqui:
+        print("\n--- Summary do AssetProcessor (Sub-Modelo) ---")
+        agent_network.asset_processor.summary()
+
+
+    except Exception as e:
+        print(f"Erro ao construir a rede principal: {e}", exc_info=True)
+        exit()
+
+    # 4. Chamar model(mock_input) para o Forward Pass
+    print("\nExecutando Forward Pass...")
+    try:
+        predictions = agent_network(mock_market_data_flat, training=False) # Passar training=False para inferência
+        print("Forward Pass concluído com sucesso!")
+    except Exception as e:
+        print(f"Erro durante o Forward Pass: {e}", exc_info=True)
+        exit()
+
+    # 5. Verificar o Shape da Saída
+    print(f"\nShape da Saída (predictions): {predictions.shape}")
+    expected_output_shape = (batch_size_test, num_assets_test)
+    if predictions.shape == expected_output_shape:
+        print(f"Shape da Saída está CORRETO! Esperado: {expected_output_shape}")
+    else:
+        print(f"ERRO: Shape da Saída INCORRETO. Esperado: {expected_output_shape}, Obtido: {predictions.shape}")
+
+    # Verificar se a saída é uma distribuição de probabilidade (softmax)
+    if hasattr(predictions, 'numpy'): # Se for um EagerTensor
+        output_sum = tf.reduce_sum(predictions, axis=-1).numpy()
+        print(f"Soma das probabilidades de saída por amostra no batch (deve ser próximo de 1): {output_sum}")
+        if np.allclose(output_sum, 1.0):
+            print("Saída Softmax parece CORRETA (soma 1).")
+        else:
+            print("AVISO: Saída Softmax pode NÃO estar correta (soma diferente de 1).")
+    
+    print("\nExemplo das primeiras predições (pesos do portfólio):")
+    print(predictions.numpy()[:min(5, batch_size_test)]) # Imprime até 5 predições do batch
+
+    # Teste com sentimento (se implementado e FinBERT carregado)
+    # agent_network.use_sentiment = True # Ativar para teste
+    # if agent_network.use_sentiment and hasattr(agent_network, 'tokenizer'):
+    #     print("\nTestando Forward Pass COM SENTIMENTO...")
+    #     mock_news_batch = ["positive news for asset 1", "market is very volatile today"] # Exemplo
+    #     # A forma como você passa 'news' para o call() precisa ser definida.
+    #     # Se for um dicionário:
+    #     # mock_inputs_with_news = {"market_data": mock_market_data_flat, "news_data": mock_news_batch}
+    #     # predictions_with_sentiment = agent_network(mock_inputs_with_news, training=False)
+    #     # print(f"Shape da Saída com Sentimento: {predictions_with_sentiment.shape}")
+    # else:
+    #     print("\nTeste com sentimento pulado (use_sentiment=False ou FinBERT não carregado).")
+
+    print("\nTeste do Forward Pass Concluído!")
+
+
+
+
+

agents/config.md

@@ -0,0 +1,13 @@
+# EXPECTED_FEATURES_ORDER define como as colunas DEVEM ESTAR no DataFrame
+# que entra na função create_sequences, APÓS o escalonamento e ANTES do sufixo _scaled.
+# E também como o rnn_predictor.py espera as features ANTES de aplicar os scalers.
+# Se rnn_predictor.py vai aplicar scalers separados, ele precisa dos nomes originais (ou _div_atr).
+# O script de treino vai criar colunas com sufixo _scaled para alimentar o modelo.
+# A lista EXPECTED_FEATURES_ORDER no config.py não é diretamente usada no train_rnn_model.py
+# da forma como está agora, mas é CRUCIAL para alinhar com rnn_predictor.py.
+# Fazer o train_rnn_model.py funcionar e depois alinhar o rnn_predictor.py.
+# Importante que as NUM_FEATURES e o input_shape do modelo estejam corretos.
+
+# Esta variável será usada para nomear as colunas escaladas que vão para o modelo
+# e deve corresponder ao que o rnn_predictor.py espera encontrar como features escaladas.
+# Os nomes aqui devem ser as colunas de BASE_FEATURE_COLS com "_scaled" no final.

agents/config.py

@@ -0,0 +1,126 @@
+# config.py
+
+# --- Parâmetros de Dados ---
+SYMBOL = 'ETH/USDT'  # Ativo principal para o modelo de classificação (se ainda usar)
+MULTI_ASSET_SYMBOLS = { # Para o agente de portfólio RL
+    'eth': 'ETH-USD',  # Chave amigável: ticker_yfinance
+    'btc': 'BTC-USD',
+    'ada': 'ADA-USD',
+    'sol': 'SOL-USD'
+}
+NUM_ASSETS_PORTFOLIO = len(MULTI_ASSET_SYMBOLS) # Número de ativos no portfólio
+NUM_ASSETS=4
+TIMEFRAME = '1h' # Usado tanto para yfinance quanto para ccxt (se adaptar)
+DAYS_OF_DATA_TO_FETCH = 365 * 2
+LIMIT_PER_FETCH = 1000 # Para ccxt
+
+# --- Parâmetros de Features e Janela ---
+WINDOW_SIZE = 60
+
+# BASE_FEATURE_COLS: Colunas calculadas para CADA ativo ANTES do escalonamento final para o modelo.
+# Estas são as features que seu data_handler_multi_asset.py DEVE produzir para cada ativo.
+# O rnn_predictor.py (ou a parte de features da DeepPortfolioAgentNetwork) também as calculará.
+BASE_FEATURES_PER_ASSET_INPUT = [ # Renomeado para clareza
+    'open_div_atr', 'high_div_atr', 'low_div_atr', 'close_div_atr', 'volume_div_atr',
+    'log_return', 'rsi_14', 'atr', 'bbp', 'cci_37', 'mfi_37',
+    'body_size_norm_atr', 'body_vs_avg_body', 'macd', 'sma_10_div_atr',
+    'adx_14', 'volume_zscore', 'buy_condition_v1'
+    # Se 'cond_compra_v1' for diferente de 'buy_condition_v1', adicione aqui.
+    # Se for igual, remova a redundância. Assumindo que 'buy_condition_v1' é a correta.
+]
+# Nomes das colunas de preço/volume (normalizadas por ATR) que usarão o price_vol_scaler
+API_PRICE_VOL_COLS = ['open_div_atr', 'high_div_atr', 'low_div_atr', 'close_div_atr', 'volume_div_atr', 'body_size_norm_atr']
+# Nomes das colunas de indicadores (e outras) que usarão o indicator_scaler
+API_INDICATOR_COLS = [col for col in BASE_FEATURES_PER_ASSET_INPUT if col not in API_PRICE_VOL_COLS]
+
+# Número de features que CADA ativo terá após todos os cálculos e ANTES do escalonamento final.
+NUM_FEATURES_PER_ASSET = len(BASE_FEATURES_PER_ASSET_INPUT)
+
+# Nomes das colunas escaladas que o modelo RNN/RL efetivamente verá como entrada.
+# Esta é a ordem que deve ser mantida após o escalonamento no data_handler e no rnn_predictor.
+# E também o que o create_sequences espera.
+EXPECTED_SCALED_FEATURES_FOR_MODEL = [f"{col}_scaled" for col in BASE_FEATURES_PER_ASSET_INPUT]
+# NUM_FEATURES_MODEL_INPUT será len(EXPECTED_SCALED_FEATURES_FOR_MODEL), que é igual a NUM_FEATURES_PER_ASSET
+
+# --- Parâmetros do Alvo da Predição (Para o Modelo de Classificação Supervisionado, se ainda usar) ---
+PREDICTION_HORIZON = 5
+PRICE_CHANGE_THRESHOLD = 0.0075
+
+# --- Parâmetros da Rede Neural (DeepPortfolioAgentNetwork e seu AssetProcessor) ---
+# Para AssetProcessor (processamento individual de ativo)
+ASSET_CNN_FILTERS1 = 32
+ASSET_CNN_FILTERS2 = 64
+ASSET_LSTM_UNITS1 = 64
+ASSET_LSTM_UNITS2 = 32  # Saída do AssetProcessor, se torna a dimensão da feature latente por ativo
+ASSET_DROPOUT = 0.2
+
+# Para DeepPortfolioAgentNetwork (camadas após processamento individual)
+MHA_NUM_HEADS = 4
+# key_dim da MHA será ASSET_LSTM_UNITS2 // MHA_KEY_DIM_DIVISOR
+MHA_KEY_DIM_DIVISOR = 2 # Ex: 32 // 2 = 16. Garanta que ASSET_LSTM_UNITS2 seja divisível. Se não, ajuste.
+
+# Camadas densas FINAIS DENTRO da DeepPortfolioAgentNetwork, ANTES da saída de features latentes
+# ou da camada de alocação softmax (se não estiver retornando features latentes).
+# `FINAL_DENSE_UNITS2_EXTRACTOR` será a dimensão das features que o extrator cospe para o SB3.
+DPN_FINAL_DENSE1_UNITS = 64 # "DPN" para DeepPortfolioNetwork
+DPN_LATENT_FEATURE_DIM = 32 # Saída da DPN quando output_latent_features=True. IGUAL A ASSET_LSTM_UNITS2 se não houver mais camadas após GAP.
+                            # Se você adicionou Dense(final_dense_units1) e Dense(final_dense_units2) APÓS a atenção
+                            # no DeepPortfolioAgentNetwork, então DPN_LATENT_FEATURE_DIM seria final_dense_units2.
+                            # No nosso último design, era a saída do global_avg_pool_attention, então ASSET_LSTM_UNITS2.
+                            # Vamos assumir que a saída do GAP é usada como feature latente por enquanto.
+                            # DPN_LATENT_FEATURE_DIM = ASSET_LSTM_UNITS2
+
+# Ajustando com base no seu código de `deep_portfolio.py` onde você tinha `final_dense_units1` e `final_dense_units2`
+# após a atenção e antes do output de alocação.
+# Estas são as camadas que produzem as features latentes para SB3.
+DPN_SHARED_HEAD_DENSE1_UNITS = 128 # Corresponde a final_dense_units1 na sua DeepPortfolioAgentNetwork
+DPN_SHARED_HEAD_LATENT_DIM = 64   # Corresponde a final_dense_units2, que será o self.features_dim do extrator
+DPN_SHARED_HEAD_DROPOUT = 0.3
+
+DEFAULT_EXTRACTOR_KWARGS=DPN_SHARED_HEAD_DENSE1_UNITS
+
+# Para as cabeças de Política (Ator) e Valor (Crítico) no Stable-Baselines3 (APÓS o extrator)
+# Se vazias, a saída do extrator é usada diretamente para as camadas finais de ação/valor.
+POLICY_HEAD_NET_ARCH = [64]  # Ex: [64, 32] ou [] se não quiser camadas extras
+VALUE_HEAD_NET_ARCH = [64]   # Ex: [64, 32] ou []
+
+# --- Parâmetros Gerais do Modelo (se aplicável a ambos os tipos de modelo) ---
+MODEL_DROPOUT_RATE = 0.3      # Você usou 0.3 na última rodada de classificação bem-sucedida
+MODEL_L2_REG = 0.0001         # Você usou 0.0001 ou 0.0005
+
+L2_REG = 0.0001 
+
+# --- Parâmetros de Treinamento ---
+# Para o modelo de classificação supervisionado (se ainda usar)
+SUPERVISED_LEARNING_RATE = 0.0005
+SUPERVISED_BATCH_SIZE = 128
+SUPERVISED_EPOCHS = 100
+LEARNING_RATE=0.0005
+
+# Para o agente RL (PPO)
+PPO_LEARNING_RATE = 0.0003 # Padrão do SB3 PPO, pode ajustar
+PPO_N_STEPS = 2048
+PPO_BATCH_SIZE_RL = 64 # Mini-batch size do PPO
+PPO_ENT_COEF = 0.01
+PPO_TOTAL_TIMESTEPS = 1000000 # Comece com menos para teste (ex: 50k-100k)
+
+# --- Parâmetros do Ambiente RL ---
+# RISK_FREE_RATE_ANNUAL = 0.02 # Taxa livre de risco anual (ex: 2%)
+# REWARD_WINDOW_SHARPE = 252 * 1 # Ex: Janela de 1 ano de dados horários para Sharpe (252 dias * 24h)
+                               # Ou uma janela menor como 60 ou 120 passos.
+INITIAL_BALANCE = 100000
+TRANSACTION_COST_PCT = 0.001 # 0.1%
+
+# --- Caminhos para Salvar ---
+MODEL_ROOT_DIR = "app/model" # Diretório raiz para todos os modelos e scalers
+# Para modelo de classificação supervisionado (se mantiver)
+SUPERVISED_MODEL_NAME = "classification_model.h5"
+SUPERVISED_PV_SCALER_NAME = "supervisor_pv_scaler.joblib"
+SUPERVISED_IND_SCALER_NAME = "supervisor_ind_scaler.joblib"
+# Para modelo RL (agente PPO salvo pelo SB3)
+RL_AGENT_MODEL_NAME = "ppo_deep_portfolio_agent" # SB3 adiciona .zip
+# Scalers usados para preparar dados para o DeepPortfolioAgentNetwork (que é o extrator do RL)
+RL_PV_SCALER_NAME = "rl_price_volume_atr_norm_scaler.joblib" # Seus nomes descritivos
+RL_INDICATOR_SCALER_NAME = "rl_other_indicators_scaler.joblib"
+FINAL_DENSE_UNITS1_EXTRACTOR=DEFAULT_EXTRACTOR_KWARGS
+USE_SENTIMENT_CONFIG=True

agents/custom_policies.py

@@ -0,0 +1,99 @@
+# rnn/agents/custom_policies.py (NOVO ARQUIVO, ou adicione ao deep_portfolio.py)
+
+import gymnasium as gym # Usar gymnasium
+import tensorflow as tf
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor as PyTorchBaseFeaturesExtractor
+
+from stable_baselines3.common.torch_layers import MlpExtractor
+import torch.nn as nn
+import torch
+
+class CustomTFMlpExtractor(tf.keras.layers.Layer):
+    def __init__(self, feature_dim, net_arch, activation_fn=tf.nn.relu):
+        super().__init__()
+        self.net = tf.keras.Sequential()
+        for units in net_arch:
+            self.net.add(tf.keras.layers.Dense(units))
+            self.net.add(tf.keras.layers.Activation(activation_fn))
+
+    def call(self, inputs, training=False):
+        return self.net(inputs, training=training)
+
+
+
+class CustomMlpExtractor(MlpExtractor):
+    def __init__(self, input_dim, net_arch, activation_fn, device):
+        super().__init__(input_dim, net_arch, activation_fn, device)
+
+    def forward(self, features):
+        for layer in self.policy_net:
+            if isinstance(layer, nn.ReLU):
+                features = layer(features)  # Passando 'features' como argumento
+            else:
+                features = layer(features)
+        return features
+# Para TensorFlow, precisamos de um extrator de features compatível ou construir a política de forma diferente.
+# Stable Baselines3 tem melhor suporte nativo para PyTorch. Para TF, é um pouco mais manual.
+# VAMOS USAR A ABORDAGEM DE POLÍTICA CUSTOMIZADA COM TF DIRETAMENTE.
+from stable_baselines3.common.policies import ActorCriticPolicy
+from typing import List, Dict, Any, Optional, Union, Type
+# Importar sua rede e configs
+#import agents.DeepPortfolioAgent as DeepPortfolioAgent
+from portfolio_features_extractor_torch import PortfolioFeaturesExtractorTorch
+# from ..config import (NUM_ASSETS, WINDOW_SIZE, NUM_FEATURES_PER_ASSET, ...) # Importe do seu config real
+# VALORES DE EXEMPLO (PEGUE DO SEU CONFIG.PY REAL)
+NUM_ASSETS_POLICY = 4
+WINDOW_SIZE_POLICY = 60
+NUM_FEATURES_PER_ASSET_POLICY = 26
+# Hiperparâmetros para DeepPortfolioAgentNetwork quando usada como extrator
+ASSET_CNN_FILTERS1_POLICY = 32
+ASSET_CNN_FILTERS2_POLICY = 64
+ASSET_LSTM_UNITS1_POLICY = 64
+ASSET_LSTM_UNITS2_POLICY = 32 # Esta será a dimensão das features latentes para ator/crítico
+ASSET_DROPOUT_POLICY = 0.2
+MHA_NUM_HEADS_POLICY = 4
+MHA_KEY_DIM_DIVISOR_POLICY = 2 # Para key_dim = 32 // 2 = 16
+FINAL_DENSE_UNITS1_POLICY = 128
+FINAL_DENSE_UNITS2_POLICY = ASSET_LSTM_UNITS2_POLICY # A saída da dense2 SÃO as features latentes
+FINAL_DROPOUT_POLICY = 0.3
+
+
+
+
+class CustomPolicy(ActorCriticPolicy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mlp_extractor = CustomTFMlpExtractor(
+            input_dim=self.observation_space.shape[0],
+            net_arch=[64, 64],  # Exemplo de arquitetura
+            activation_fn=nn.ReLU,
+            device=self.device
+        )
+
+from torch import nn
+
+class CustomPortfolioPolicySB3(ActorCriticPolicy):
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule,
+        net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None,
+        activation_fn: Type[nn.Module] = nn.ReLU,  # Use PyTorch ReLU
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        if features_extractor_kwargs is None:
+            features_extractor_kwargs = {}
+        features_extractor_kwargs.setdefault("features_dim", ASSET_LSTM_UNITS2_POLICY)
+
+        super().__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch=net_arch,
+            activation_fn=activation_fn,  # Passando nn.ReLU
+            features_extractor_class=PortfolioFeaturesExtractorTorch,
+            features_extractor_kwargs=features_extractor_kwargs,
+            **kwargs,
+        )

agents/data_handler_multi_asset.py

@@ -0,0 +1,448 @@
+# rnn/data_handler_multi_asset.py (NOVO ARQUIVO)
+
+
+import pandas as pd
+import numpy as np
+import yfinance as yf # Ou ccxt, dependendo da sua preferência de fonte de dados
+import pandas_ta as ta
+from datetime import datetime, timedelta, timezone
+from typing import List, Dict, Optional
+
+WINDOW_SIZE = 60
+
+# Importar do seu config.py
+# Assumindo que config.py está em ../config.py ou rnn/config.py
+# Ajuste o import conforme sua estrutura.
+# Se train_rnn_model.py e este data_handler estiverem na mesma pasta 'scripts',
+# e config.py estiver um nível acima:
+# from ..app/config.py import (
+#     MULTI_ASSET_LIST, TIMEFRAME, DAYS_OF_DATA_TO_FETCH, 
+#     # etc. para features a serem calculadas
+# )
+# Por agora, vamos definir aqui para exemplo:
+
+# EXEMPLO DE CONFIGURAÇÃO (Mova para config.py depois)
+MULTI_ASSET_SYMBOLS = {
+    'eth': 'ETH-USD', 
+    'btc': 'BTC-USD',
+    'ada': 'ADA-USD',
+    'sol': 'SOL-USD' 
+} # Use os tickers corretos para yfinance ou ccxt
+TIMEFRAME_YFINANCE = '1h' # yfinance suporta '1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo'
+# Para '1h', yfinance só retorna os últimos 730 dias. Para mais dados, use '1d'.
+# Se usar ccxt, TIMEFRAME = '1h' como antes.
+DAYS_TO_FETCH = 365 * 2 # 2 anos
+
+# Lista das features base que você quer calcular para CADA ativo
+# (as 19 que definimos antes)
+INDIVIDUAL_ASSET_BASE_FEATURES = [
+    'open', 'high', 'low', 'close', 'volume', # OHLCV originais são necessários para os cálculos
+    'sma_10', 'rsi_14', 'macd', 'macds', 'atr', 'bbp', 'cci_37', 'mfi_37', 'adx_14',
+    'volume_zscore', 'body_size', 'body_size_norm_atr', 'body_vs_avg_body',
+    'log_return', 'buy_condition_v1',
+    'open_div_atr', 'high_div_atr', 
+    'low_div_atr', 
+    'close_div_atr', 
+    'volume_div_atr',
+    'sma_10_div_atr' # 'sma_50' é calculada dentro de buy_condition_v1
+    # As colunas _div_atr serão criadas a partir destas
+]
+
+# Features que serão normalizadas pelo ATR
+COLS_TO_NORM_BY_ATR = ['open', 'high', 'low', 'close', 'volume', 'sma_10', 'macd', 'body_size']
+#----------------------------------
+# -- New get multi asset data for rl
+# ... (imports e outras funções como antes) ...
+
+def get_multi_asset_data_for_rl(
+    asset_symbols_map: Dict[str, str], 
+    timeframe_yf: str, 
+    days_to_fetch: int,
+    logger_instance # Adicionar logger como parâmetro
+) -> Optional[pd.DataFrame]: # Adicionar logger como parâmetro
+
+    all_asset_features_list: List[pd.DataFrame] = [] # Tipagem para clareza
+    min_data_length = float('inf')
+    print(all_asset_features_list)
+    
+    #logger_instance.info(f"Iniciando get_multi_asset_data_for_rl para: {list(asset_symbols_map.keys())}")
+
+    for asset_key, yf_ticker in asset_symbols_map.items():
+        #logger_instance.info(f"\n--- Processando {asset_key} ({yf_ticker}) ---")
+        # ... (lógica de fetch_single_asset_ohlcv_yf como antes) ...
+        single_asset_ohlcv = fetch_single_asset_ohlcv_yf(yf_ticker, period=f"{days_to_fetch}d", interval=timeframe_yf) # Passar logger se a função aceitar
+
+        # if single_asset_ohlcv.empty:
+        #     logger_instance.warning(f"Sem dados OHLCV para {yf_ticker}, pulando.")
+        #     continue
+            
+        single_asset_features = calculate_all_features_for_single_asset(single_asset_ohlcv)#, logger_instance) 
+        
+        if single_asset_features is None or single_asset_features.empty:
+            logger_instance.warning(f"Sem features calculadas para {yf_ticker}, pulando.")
+            continue
+        
+        #logger_instance.info(f"Features para {asset_key} shape: {single_asset_features.shape}, Index Min: {single_asset_features.index.min()}, Index Max: {single_asset_features.index.max()}")
+        
+        # Garantir que o índice é DatetimeIndex e UTC para todos antes de adicionar prefixo e à lista
+        if not isinstance(single_asset_features.index, pd.DatetimeIndex):
+            single_asset_features.index = pd.to_datetime(single_asset_features.index)
+        if single_asset_features.index.tz is None:
+            single_asset_features.index = single_asset_features.index.tz_localize('UTC')
+        else:
+            single_asset_features.index = single_asset_features.index.tz_convert('UTC')
+
+        single_asset_features = single_asset_features.add_prefix(f"{asset_key}_")
+        all_asset_features_list.append(single_asset_features)
+        min_data_length = min(min_data_length, len(single_asset_features))
+
+    if not all_asset_features_list:
+        logger_instance.error("Nenhum DataFrame de feature de ativo foi adicionado à lista.")
+        return None
+
+    if min_data_length == float('inf') or min_data_length < WINDOW_SIZE: # Adicionada checagem de WINDOW_SIZE
+        logger_instance.error(f"min_data_length inválido ({min_data_length}) ou menor que WINDOW_SIZE ({WINDOW_SIZE}). Não é possível truncar/usar.")
+        return None
+
+    #logger_instance.info(f"Menor número de linhas de dados encontrado (min_data_length): {min_data_length}")
+    
+    # Truncar para garantir que todos os DFs tenham o mesmo comprimento ANTES do concat
+    # E que tenham pelo menos min_data_length.
+    # É importante que os ÍNDICES de data/hora se sobreponham para o join='inner' funcionar.
+    # Apenas pegar o .tail() pode não alinhar os timestamps se os DFs tiverem começos diferentes.
+    
+    # Melhor abordagem: encontrar o índice comum mais recente e o mais antigo.
+    if not all_asset_features_list: # Checagem se a lista não ficou vazia por algum motivo
+        logger_instance.error("all_asset_features_list está vazia antes do alinhamento de índice.")
+        return None
+    print(all_asset_features_list)
+    # Alinhar DataFrames por um índice comum antes de concatenar
+    # 1. Encontrar o primeiro timestamp comum a todos
+    # 2. Encontrar o último timestamp comum a todos
+    # Ou, mais simples, confiar no join='inner' do concat, mas garantir que os DFs são válidos.
+
+    # Vamos simplificar e manter o truncamento pelo tail, mas com mais logs
+    # e garantir que são DataFrames.
+    
+    truncated_asset_features_list = []
+    for i, df_asset in enumerate(all_asset_features_list):
+        if isinstance(df_asset, pd.DataFrame) and len(df_asset) >= min_data_length:
+            truncated_df = df_asset.tail(min_data_length)
+            #logger_instance.info(f"  DF truncado {i} ({df_asset.columns[0].split('_')[0]}): shape {truncated_df.shape}, ")
+                                 #f"Index Min: {truncated_df.index.min()}, Max: {truncated_df.index.max()}")
+            truncated_asset_features_list.append(truncated_df)
+        else:
+            asset_name_debug = df_asset.columns[0].split('_')[0] if isinstance(df_asset, pd.DataFrame) and not df_asset.empty else f"DF_{i}"
+            logger_instance.warning(f"  DF {asset_name_debug} inválido ou muito curto (len: {len(df_asset) if isinstance(df_asset, pd.DataFrame) else 'N/A'}) para truncamento. Pulando.")
+
+    if not truncated_asset_features_list:
+        #ogger_instance.error("Nenhum DataFrame válido restou após truncamento para concatenar.")
+        return None
+    
+    # Se houver apenas UM DataFrame na lista, não precisa concatenar, apenas retorna ele.
+    if len(truncated_asset_features_list) == 1:
+        #logger_instance.info("Apenas um DataFrame de ativo processado, retornando-o diretamente.")
+        combined_df = truncated_asset_features_list[0]
+    else:
+        #logger_instance.info(f"Concatenando {len(truncated_asset_features_list)} DataFrames de ativos com join='inner'...")
+        try:
+            combined_df = pd.concat(truncated_asset_features_list, axis=1, join='outer')
+            print(combined_df)
+        except Exception as e_concat:
+            logger_instance.error(f"ERRO CRÍTICO durante pd.concat: {e_concat}", exc_info=True)
+            return None
+        
+
+    combined_df.fillna(method='ffill', inplace=True)
+    # Depois do ffill, ainda pode haver NaNs no início se algum ativo começar depois dos outros.
+    if not combined_df.empty:
+        #logger_instance.info(f"Shape após ffill: {combined_df.shape}. Buscando primeiro/último índice válido...")
+        first_valid_index = combined_df.first_valid_index()
+        last_valid_index = combined_df.last_valid_index()
+
+    if pd.isna(first_valid_index) or pd.isna(last_valid_index):
+        print("Não foi possível determinar first/last_valid_index após ffill.")
+        return None
+    
+    print(f"Primeiro índice válido: {first_valid_index}, Último índice válido: {last_valid_index}")
+    combined_df = combined_df.loc[first_valid_index:last_valid_index]
+    print(f"Shape após fatiar por first/last valid index: {combined_df.shape}")
+    
+    # Um dropna final pode ser necessário se o ffill não pegou tudo (improvável, mas seguro)
+    combined_df.dropna(inplace=True) 
+    print(f"Shape após dropna final (pós-fatiamento): {combined_df.shape}")
+    print("Imprimindo DF_COMBINED com index ")
+    print(combined_df)
+
+    #logger_instance.info(f"Tipo de combined_df após concat: {type(combined_df)}")
+    if not isinstance(combined_df, pd.DataFrame):
+        logger_instance.error(f"combined_df NÃO é um DataFrame após concat. Tipo: {type(combined_df)}")
+        return None
+    
+
+    return combined_df
+    # if combined_df.empty:
+                              
+    #     logger_instance.error("DataFrame combinado está VAZIO após concatenação e join='inner'. "
+    #                           "Isso geralmente significa que não há timestamps comuns entre TODOS os ativos processados.")
+    #     # Adicionar mais depuração aqui se isso acontecer:
+    #     # for i, df_trunc_debug in enumerate(truncated_asset_features_list):
+    #     #     logger_instance.info(f"Debug DF {i} - Head:\n{df_trunc_debug.head(3)}")
+    #     #     logger_instance.info(f"Debug DF {i} - Tail:\n{df_trunc_debug.tail(3)}")
+    #     #     logger_instance.info(f"DataFrame combinado ANTES do dropna final, shape: {combined_df.shape}")
+    #     print(combined_df.head()) # Descomente para depuração pesada
+    # return None
+        
+    
+    
+    
+# ... 
+#----------------------------------
+
+# def get_multi_asset_data_for_rl(
+#     asset_symbols_map: Dict[str, str], 
+#     timeframe_yf: str, 
+#     days_to_fetch: int
+# ) -> Optional[pd.DataFrame]:
+#     """
+#     Busca, processa e combina dados de múltiplos ativos em um DataFrame achatado.
+#     """
+#     all_asset_features_list = []
+#     # min_data_length = float('inf') # Inicializar com um valor alto
+#     # Vamos inicializar com 0 e pegar o len do primeiro DF válido
+#     min_data_length = 0 
+#     first_valid_df_processed = False
+
+#     for asset_key, yf_ticker in asset_symbols_map.items():
+#         print(f"\n--- Processando {asset_key} ({yf_ticker}) ---")
+#         period_yf = f"{days_to_fetch}d"
+#         if timeframe_yf == '1h' and days_to_fetch > 730:
+#             print(f"AVISO: Para {timeframe_yf}, buscando no máximo 730 dias com yfinance para {yf_ticker}.")
+#             period_yf = "730d" 
+        
+#         single_asset_ohlcv = fetch_single_asset_ohlcv_yf(yf_ticker, period=period_yf, interval=timeframe_yf)
+#         if single_asset_ohlcv.empty:
+#             print(f"AVISO: Sem dados OHLCV para {yf_ticker}, pulando este ativo.")
+#             continue
+            
+#         single_asset_features = calculate_all_features_for_single_asset(single_asset_ohlcv) # Passar logger se tiver
+#         if single_asset_features is None or single_asset_features.empty:
+#             print(f"AVISO: Sem features calculadas para {yf_ticker}, pulando este ativo.")
+#             continue
+        
+#         single_asset_features = single_asset_features.add_prefix(f"{asset_key}_")
+#         all_asset_features_list.append(single_asset_features)
+        
+#         # Atualizar min_data_length de forma mais segura
+#         if not first_valid_df_processed:
+#             min_data_length = len(single_asset_features)
+#             first_valid_df_processed = True
+#         else:
+#             min_data_length = min(min_data_length, len(single_asset_features))
+
+#     if not all_asset_features_list: # Se nenhum ativo foi processado com sucesso
+#         print("ERRO: Nenhum dado de feature de ativo foi processado com sucesso para a lista `all_asset_features_list`.")
+#         return None # Retorna None, que não tem '.empty' mas será checado por 'is None'
+
+#     if min_data_length == 0 : # Checagem adicional se algo deu muito errado
+#         print("ERRO: min_data_length é zero após processar ativos, não é possível truncar DataFrames.")
+#         return None
+
+#     print(f"Menor número de linhas de dados encontrado entre os ativos (min_data_length): {min_data_length}")
+#     truncated_asset_features_list = [df.tail(min_data_length) for df in all_asset_features_list if not df.empty and len(df) >= min_data_length]
+
+#     # Verificar se a lista de DFs truncados não está vazia ANTES de concatenar
+#     if not truncated_asset_features_list:
+#         print("ERRO: Nenhum DataFrame válido restou após o truncamento. Não é possível concatenar.")
+#         return None
+
+#     print(f"Concatenando {len(truncated_asset_features_list)} DataFrames de ativos...")
+#     try:
+#         combined_df = pd.concat(truncated_asset_features_list, axis=1, join='inner')
+#     except Exception as e_concat:
+#         print(f"ERRO durante pd.concat: {e_concat}")
+#         return None # Retorna None em caso de erro na concatenação
+
+#     # Agora, combined_df DEVE ser um DataFrame (mesmo que vazio se o join falhar)
+#     if not isinstance(combined_df, pd.DataFrame):
+#         print(f"ERRO: pd.concat não retornou um DataFrame. Tipo retornado: {type(combined_df)}")
+#         return None
+
+#     if combined_df.empty: # Esta checagem agora deve funcionar ou ser desnecessária se o anterior já retornou None
+#         print("ERRO: DataFrame combinado está vazio após concatenação e join. Verifique os dados dos ativos e o alinhamento de datas.")
+#         return None
+        
+#     combined_df.dropna(inplace=True)
+    
+#     if combined_df.empty: # Checagem final após dropna
+#         print("ERRO: DataFrame combinado está vazio após dropna final.")
+#         return None
+
+#     print(f"\nDataFrame multi-ativo final gerado com shape: {combined_df.shape}")
+#     return combined_df
+
+
+
+
+def fetch_single_asset_ohlcv_yf(ticker_symbol: str, period: str = "2y", interval: str = "1h") -> pd.DataFrame:
+    """ Adaptação da sua função fetch_historical_ohlcv de financial_data_agent.py """
+    print(f"Buscando dados para {ticker_symbol} com yfinance (period: {period}, interval: {interval})...")
+    try:
+        ticker = yf.Ticker(ticker_symbol)
+        # Para dados horários, o período máximo é geralmente 730 dias com yfinance
+        # Se precisar de mais, considere '1d' e depois reamostre, ou use ccxt para cripto.
+        if interval == '1h' and period.endswith('y') and int(period[:-1]) * 365 > 730:
+             print(f"AVISO: yfinance pode limitar dados horários a 730 dias. Buscando 'max' para {interval} e depois fatiando.")
+             data = ticker.history(interval=interval, period="730d") # Pega o máximo possível
+        elif interval == '1d' and period.endswith('y'):
+             data = ticker.history(period=period, interval=interval)
+        else: # Para períodos menores ou outros intervalos
+            data = ticker.history(period=period, interval=interval)
+
+        if data.empty:
+            print(f"Nenhum dado encontrado para {ticker_symbol}.")
+            return pd.DataFrame()
+        
+        data.rename(columns={
+            "Open": "open", "High": "high", "Low": "low", 
+            "Close": "close", "Volume": "volume", "Adj Close": "adj_close"
+        }, inplace=True)
+        
+        # Selecionar apenas as colunas OHLCV e garantir que o índice é DatetimeIndex UTC
+        data = data[['open', 'high', 'low', 'close', 'volume']]
+        if data.index.tz is None:
+            data.index = data.index.tz_localize('UTC')
+        else:
+            data.index = data.index.tz_convert('UTC')
+
+        # Para dados horários, yfinance pode retornar dados do fim de semana (sem volume)
+        # e o último candle pode estar incompleto.
+        # if interval == '1h':
+        #     data = data[data['volume'] > 0] # Remover candles sem volume
+            # data = data[:-1] # Remover o último candle que pode estar incompleto
+
+        print(f"Dados coletados para {ticker_symbol}: {len(data)} linhas.")
+        return data
+    except Exception as e:
+        print(f"Erro ao buscar dados para {ticker_symbol} com yfinance: {e}")
+        return pd.DataFrame()
+
+
+def calculate_all_features_for_single_asset(ohlcv_df: pd.DataFrame) -> Optional[pd.DataFrame]:
+    """Calcula todas as features base para um único ativo."""
+    if ohlcv_df.empty: return None
+    df = ohlcv_df.copy()
+    print(f"Calculando features para ativo (shape inicial: {df.shape})...")
+
+    # GARANTIR que a coluna 'close' original será preservada no DataFrame final
+    if 'close' in df.columns:
+        df['close'] = df['close']  # redundante, mas deixa explícito que não será sobrescrita
+
+    if ta:
+        df.ta.sma(length=10, close='close', append=True, col_names=('sma_10',))
+        df.ta.rsi(length=14, close='close', append=True, col_names=('rsi_14',))
+        macd_out = df.ta.macd(close='close', append=False)
+        if macd_out is not None and not macd_out.empty:
+            df['macd'] = macd_out.iloc[:,0]
+            df['macds'] = macd_out.iloc[:,2] # Linha de sinal para buy_condition
+        df.ta.atr(length=14, append=True, col_names=('atr',))
+        df.ta.bbands(length=20, close='close', append=True, col_names=('bbl', 'bbm', 'bbu', 'bbb', 'bbp'))
+        df.ta.cci(length=37, append=True, col_names=('cci_37',))
+        df['volume'] = df['volume'].astype(float) 
+        df.ta.mfi(length=37, close='close', high='high', low='low', volume='volume', append=True, col_names=('mfi_37',))
+        df.ta.mfi(length=37, append=True, col_names=('mfi_37',))
+        adx_out = df.ta.adx(length=14, append=False)
+        if adx_out is not None and not adx_out.empty:
+             df['adx_14'] = adx_out.iloc[:,0]
+        
+        rolling_vol_mean = df['volume'].rolling(window=20).mean()
+        rolling_vol_std = df['volume'].rolling(window=20).std()
+        df['volume_zscore'] = (df['volume'] - rolling_vol_mean) / (rolling_vol_std + 1e-9)
+
+        df['body_size'] = abs(df['close'] - df['open'])
+        
+        # ATR precisa existir para as próximas. Drop NaNs do ATR primeiro.
+        df.dropna(subset=['atr'], inplace=True)
+        df_atr_valid = df[df['atr'] > 1e-9].copy()
+        if df_atr_valid.empty:
+            print("AVISO: ATR inválido para todas as linhas restantes, features _div_atr e body_size_norm_atr podem ser todas NaN ou vazias.")
+            # Criar colunas com NaN para manter a estrutura
+            df['body_size_norm_atr'] = np.nan
+            for col in COLS_TO_NORM_BY_ATR:
+                df[f'{col}_div_atr'] = np.nan
+        else:
+            df['body_size_norm_atr'] = df['body_size'] / df['atr'] # ATR já filtrado para > 1e-9
+            for col in COLS_TO_NORM_BY_ATR:
+                if col in df.columns:
+                    df[f'{col}_div_atr'] = df[col] / (df['atr'] + 1e-9) # Adicionar 1e-9 aqui também por segurança
+                else:
+                    df[f'{col}_div_atr'] = np.nan
+
+
+        df['body_vs_avg_body'] = df['body_size'] / (df['body_size'].rolling(window=20).mean() + 1e-9)
+        df['log_return'] = np.log(df['close'] / df['close'].shift(1))
+        
+        sma_50_series = df.ta.sma(length=50, close='close', append=False)
+        if sma_50_series is not None: df['sma_50'] = sma_50_series
+        else: df['sma_50'] = np.nan
+        
+        if all(col in df.columns for col in ['macd', 'macds', 'rsi_14', 'close', 'sma_50']):
+            df['buy_condition_v1'] = ((df['macd'] > df['macds']) & (df['rsi_14'] > 50) & (df['close'] > df['sma_50'])).astype(int)
+        else:
+            df['buy_condition_v1'] = 0
+        
+        # Selecionar apenas as colunas que realmente usaremos como features base para o modelo
+        # (incluindo as _div_atr e as originais que não foram normalizadas por ATR)
+        # Esta lista de features é a que será passada para os scalers no script de treino.
+        # E também as colunas que o rnn_predictor.py precisará ter antes de aplicar seus scalers.
+        # Esta lista deve vir do config.py (BASE_FEATURE_COLS)
+        
+        # Exemplo:
+        # final_feature_columns = [
+        #    'open_div_atr', 'high_div_atr', 'low_div_atr', 'close_div_atr', 'volume_div_atr', 
+        #    'log_return', 'rsi_14', 'atr', 'bbp', 'cci_37', 'mfi_37', 
+        #    'body_size_norm_atr', 'body_vs_avg_body', 'macd', 'sma_10_div_atr', 
+        #    'adx_14', 'volume_zscore', 'buy_condition_v1'
+        # ] # Esta é a BASE_FEATURE_COLS do seu config.py
+
+        # Verificar se todas as colunas em INDIVIDUAL_ASSET_BASE_FEATURES existem
+        # (INDIVIDUAL_ASSET_BASE_FEATURES deve ser igual a config.BASE_FEATURE_COLS)
+        current_feature_cols = [col for col in INDIVIDUAL_ASSET_BASE_FEATURES if col in df.columns]
+        missing_cols = [col for col in INDIVIDUAL_ASSET_BASE_FEATURES if col not in df.columns]
+        if missing_cols:
+            print(f"AVISO: Colunas de features ausentes após cálculo: {missing_cols}. Usando apenas as disponíveis: {current_feature_cols}")
+        # GARANTIR que 'close' (preço original) está presente nas features finais
+        if 'close' not in current_feature_cols and 'close' in df.columns:
+            current_feature_cols.append('close')
+        
+        df_final_features = df[current_feature_cols].copy()
+        df_final_features.dropna(inplace=True)
+        print(f"Features calculadas. Shape após dropna: {df_final_features.shape}. Colunas: {df_final_features.columns.tolist()}")
+        return df_final_features
+    else:
+        print("pandas_ta não está disponível.")
+        return None
+
+
+if __name__ == '__main__':
+    print("Testando data_handler_multi_asset.py...")
+    # Substitua pelos tickers yfinance reais que você quer usar
+    test_assets = {
+        'eth': 'ETH-USD', 
+        'btc': 'BTC-USD',
+        # 'aapl': 'AAPL' # Exemplo de ação
+    }
+    multi_asset_data = get_multi_asset_data_for_rl(
+        test_assets, 
+        timeframe_yf='1h', # Para teste rápido, período menor
+        days_to_fetch=90   # Para teste rápido, período menor
+    )
+
+    if multi_asset_data is not None and not multi_asset_data.empty:
+        print("\n--- Exemplo do DataFrame Multi-Ativo Gerado ---")
+        print(multi_asset_data.head())
+        print(f"\nShape: {multi_asset_data.shape}")
+        print(f"\nInfo:")
+        multi_asset_data.info()
+    else:
+        print("\nFalha ao gerar DataFrame multi-ativo.")

agents/dataset_update_agent.py

@@ -0,0 +1,9 @@
+# agents/dataset_update_agent.py
+import pandas as pd
+from datetime import datetime
+
+def update_dataset(path="data/sp500_news.csv", new_data=pd.DataFrame()):
+    df = pd.read_csv(path)
+    combined = pd.concat([df, new_data]).drop_duplicates().reset_index(drop=True)
+    combined.to_csv(path, index=False)
+    print(f"Dataset atualizado: {path}")

agents/deep_portfolio.py

@@ -0,0 +1,104 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.layers import LSTM, Dense, Conv1D, MultiHeadAttention
+from transformers import AutoTokenizer, TFAutoModelForSequenceClassification # Changed here
+import gymnasium as gym
+from gymnasium import spaces
+
+class DeepPortfolioAI(tf.keras.Model):
+    def __init__(self, num_assets, sequence_length=60):
+        super(DeepPortfolioAI, self).__init__()
+        
+        # Parâmetros do modelo
+        self.num_assets = num_assets
+        self.sequence_length = sequence_length
+        
+        # CNN para análise de padrões técnicos
+        self.conv1 = Conv1D(64, 3, activation='relu')
+        self.conv2 = Conv1D(128, 3, activation='relu')
+        
+        # LSTM para análise temporal
+        self.lstm1 = LSTM(128, return_sequences=True)
+        self.lstm2 = LSTM(64)
+        
+        # Attention para correlações entre ativos
+        self.attention = MultiHeadAttention(num_heads=8, key_dim=64)
+        
+        # Camadas densas para decisão final
+        self.dense1 = Dense(256, activation='relu')
+        self.dense2 = Dense(128, activation='relu')
+        self.output_layer = Dense(num_assets, activation='softmax')
+        
+        # Inicializar tokenizer e modelo de sentimento
+        self.tokenizer = AutoTokenizer.from_pretrained('ProsusAI/finbert')
+        self.sentiment_model = TFAutoModelForSequenceClassification.from_pretrained('ProsusAI/finbert') # Changed here
+
+    def call(self, inputs):
+        market_data, news_data = inputs
+        
+        # Análise técnica com CNN
+        x_technical = self.conv1(market_data)
+        x_technical = self.conv2(x_technical)
+        
+        # Análise temporal com LSTM
+        x_temporal = self.lstm1(x_technical)
+        x_temporal = self.lstm2(x_temporal)
+        
+        # Attention para correlações
+        x_attention = self.attention(x_temporal, x_temporal, x_temporal)
+        
+        # Combinar com análise de sentimento
+        sentiment_embeddings = self._process_news(news_data)
+        x_combined = tf.concat([x_attention, sentiment_embeddings], axis=-1)
+        
+        # Camadas densas finais
+        x = self.dense1(x_combined)
+        x = self.dense2(x)
+        return self.output_layer(x)
+    
+    def _process_news(self, news_data):
+        inputs = self.tokenizer(news_data, return_tensors="pt", padding=True, truncation=True)
+        sentiment_scores = self.sentiment_model(**inputs).logits
+        return tf.convert_to_tensor(sentiment_scores.detach().numpy())
+
+class PortfolioEnvironment(gym.Env):
+    def __init__(self, data, initial_balance=100000):
+        super(PortfolioEnvironment, self).__init__()
+        
+        self.data = data
+        self.initial_balance = initial_balance
+        self.current_step = 0
+        
+        # Define espaços de ação e observação
+        self.action_space = spaces.Box(
+            low=0, high=1, shape=(len(data.columns),), dtype=np.float32)
+        self.observation_space = spaces.Box(
+            low=-np.inf, high=np.inf, shape=(60, len(data.columns)), dtype=np.float32)
+        
+    def reset(self):
+        self.current_step = 0
+        self.balance = self.initial_balance
+        self.portfolio = np.zeros(len(self.data.columns))
+        return self._get_observation()
+    
+    def step(self, action):
+        # Implementar lógica de negociação
+        current_prices = self.data.iloc[self.current_step]
+        next_prices = self.data.iloc[self.current_step + 1]
+        
+        # Calcular retorno
+        returns = (next_prices - current_prices) / current_prices
+        reward = np.sum(action * returns)
+        
+        # Atualizar portfolio
+        self.portfolio = action
+        self.balance *= (1 + reward)
+        
+        # Incrementar step
+        self.current_step += 1
+        done = self.current_step >= len(self.data) - 1
+        
+        return self._get_observation(), reward, done, {}
+    
+    def _get_observation(self):
+        return self.data.iloc[self.current_step-60:self.current_step].values

agents/deep_portfolio_torch.py

@@ -0,0 +1,80 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class SingleAssetProcessor(nn.Module):
+    def __init__(self, sequence_length, num_features_per_asset, cnn_filters1, cnn_filters2, lstm_units):
+        super().__init__()
+        self.conv1 = nn.Conv1d(num_features_per_asset, cnn_filters1, kernel_size=3, padding=1)
+        self.conv2 = nn.Conv1d(cnn_filters1, cnn_filters2, kernel_size=3, padding=1)
+        self.lstm = nn.LSTM(input_size=cnn_filters2, hidden_size=lstm_units, batch_first=True)
+
+    def forward(self, x):
+        # x: (batch, seq_len, num_features_per_asset)
+        x = x.transpose(1, 2)  # (batch, num_features_per_asset, seq_len)
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = x.transpose(1, 2)  # (batch, seq_len, cnn_filters2)
+        _, (h_n, _) = self.lstm(x)  # h_n: (1, batch, lstm_units)
+        return h_n.squeeze(0)  # (batch, lstm_units)
+
+class DeepPortfolioAgentNetworkTorch(nn.Module):
+    def __init__(self, num_assets, sequence_length, num_features_per_asset,
+                 asset_cnn_filters1=32, asset_cnn_filters2=64,
+                 asset_lstm_units1=64, asset_lstm_units2=32,
+                 final_dense_units1=128, final_dense_units2=32,
+                 final_dropout=0.3, mha_num_heads=4, mha_key_dim_divisor=2,
+                 output_latent_features=True, use_sentiment_analysis=False):
+        super().__init__()
+        self.num_assets = num_assets
+        self.sequence_length = sequence_length
+        self.num_features_per_asset = num_features_per_asset
+        self.output_latent_features = output_latent_features
+        self.use_sentiment_analysis = use_sentiment_analysis
+
+        # Processador individual de ativos
+        self.asset_processor = SingleAssetProcessor(
+            sequence_length, num_features_per_asset,
+            asset_cnn_filters1, asset_cnn_filters2, asset_lstm_units1
+        )
+        # Atenção multi-cabeça
+        self.attention = nn.MultiheadAttention(
+            embed_dim=asset_lstm_units1,
+            num_heads=mha_num_heads,
+            batch_first=True
+        )
+        # Pooling global
+        self.global_avg_pool = nn.AdaptiveAvgPool1d(1)
+        # Camadas densas finais
+        self.dense1 = nn.Linear(asset_lstm_units1, final_dense_units1)
+        self.dropout1 = nn.Dropout(final_dropout)
+        self.dense2 = nn.Linear(final_dense_units1, final_dense_units2)
+        self.dropout2 = nn.Dropout(final_dropout)
+        self.output_allocation = nn.Linear(final_dense_units2, num_assets)
+
+    def forward(self, x):
+        # x: (batch, seq_len, num_assets * num_features_per_asset)
+        batch_size = x.size(0)
+        # Separar cada ativo
+        asset_representations = []
+        for i in range(self.num_assets):
+            start = i * self.num_features_per_asset
+            end = (i + 1) * self.num_features_per_asset
+            asset_data = x[:, :, start:end]  # (batch, seq_len, num_features_per_asset)
+            asset_repr = self.asset_processor(asset_data)  # (batch, lstm_units1)
+            asset_representations.append(asset_repr)
+        # Empilhar ativos: (batch, num_assets, lstm_units1)
+        stacked = torch.stack(asset_representations, dim=1)
+        # Atenção multi-cabeça
+        attn_output, _ = self.attention(stacked, stacked, stacked)
+        # Pooling global sobre ativos (num_assets)
+        pooled = self.global_avg_pool(attn_output.transpose(1,2)).squeeze(-1)  # (batch, lstm_units1)
+        # Camadas densas finais
+        x = F.relu(self.dense1(pooled))
+        x = self.dropout1(x)
+        x = F.relu(self.dense2(x))
+        x = self.dropout2(x)
+        if self.output_latent_features:
+            return x  # (batch, final_dense_units2)
+        else:
+            return F.softmax(self.output_allocation(x), dim=-1)  # (batch, num_assets)

agents/financial_data_agent.py

@@ -0,0 +1,76 @@
+# agents/financial_data_agent.py
+import yfinance as yf
+import pandas as pd
+from agno.agent import Agent # Commented out
+from agno.models.anthropic import Claude # Commented out
+from agno.tools.yfinance import YFinanceTools # Commented out
+
+def get_stock_report(ticker="NVDA"): # Commented out
+    agent = Agent(
+        model=Claude(id="claude-3-7-sonnet-latest"),
+        tools=[
+            YFinanceTools(
+                stock_price=True,
+                analyst_recommendations=True,
+                company_info=True,
+                company_news=True,
+            )
+        ],
+        instructions=[
+            "Use tables to display data",
+            "Only output the report, no other text",
+        ],
+        markdown=True,
+    )
+    return agent.get_response(f"Write a financial report on {ticker}")
+
+def fetch_historical_ohlcv(ticker_symbol: str, period: str = "1y", interval: str = "1d") -> pd.DataFrame:
+    """
+    Fetches historical OHLCV data for a given ticker symbol.
+
+    Args:
+        ticker_symbol (str): The stock ticker symbol (e.g., "AAPL" for Apple on NASDAQ,
+                             "PETR4.SA" for Petrobras on B3, "000001.SS" for SSE Composite Index).
+        period (str): The period for which to download data (e.g., "1d", "5d", "1mo", "3mo", "6mo", "1y", "2y", "5y", "10y", "ytd", "max").
+        interval (str): The interval of data points (e.g., "1m", "2m", "5m", "15m", "30m", "60m", "90m", "1h", "1d", "5d", "1wk", "1mo", "3mo").
+
+    Returns:
+        pd.DataFrame: A pandas DataFrame containing the OHLCV data, or an empty DataFrame if an error occurs.
+    """
+    try:
+        ticker = yf.Ticker(ticker_symbol)
+        data = ticker.history(period=period, interval=interval)
+        if data.empty:
+            print(f"No data found for {ticker_symbol} for the given period/interval.")
+            return pd.DataFrame()
+        # Ensure column names are consistent (Yahoo Finance sometimes uses 'Adj Close')
+        data.rename(columns={"Adj Close": "Adj_Close"}, inplace=True)
+        return data
+    except Exception as e:
+        print(f"Error fetching data for {ticker_symbol}: {e}")
+        return pd.DataFrame()
+
+if __name__ == '__main__':
+    # Example usage:
+    # NASDAQ
+    aapl_data = fetch_historical_ohlcv("AAPL", period="1mo", interval="1d")
+    if not aapl_data.empty:
+        print("\nAAPL Data (NASDAQ):")
+        print(aapl_data.head())
+
+    # B3 (Brazilian Stock Exchange) - Example: Petrobras
+    petr4_data = fetch_historical_ohlcv("PETR4.SA", period="1mo", interval="1d")
+    if not petr4_data.empty:
+        print("\nPETR4.SA Data (B3):")
+        print(petr4_data.head())
+
+    # Asian Market - Example: Samsung Electronics (Korea Exchange)
+    samsung_data = fetch_historical_ohlcv("005930.KS", period="1mo", interval="1d")
+    if not samsung_data.empty:
+        print("\n005930.KS Data (Samsung - KRX):")
+        print(samsung_data.head())
+    
+    # Example for a non-existent ticker or error
+    error_data = fetch_historical_ohlcv("NONEXISTENTTICKER", period="1d")
+    if error_data.empty:
+        print("\nSuccessfully handled non-existent ticker.")

agents/investment_agent.py

@@ -0,0 +1,7 @@
+# agents/investment_agent.py
+def execute_investment(prediction, threshold=0.8):
+    if prediction > threshold:
+        print("Comprar ativos com probabilidade:", prediction)
+        # chamada API para execução real
+    else:
+        print("Não investir. Probabilidade baixa:", prediction)

agents/portfolio_environment.py

@@ -0,0 +1,246 @@
+# agents/portfolio_environment.py (ou atcoin_env.py)
+
+from typing import List
+import numpy as np
+import pandas as pd
+import gymnasium as gym
+from gymnasium import spaces
+from collections import deque
+
+# Importar do config.py
+# from ..config import WINDOW_SIZE # Ajuste o import
+WINDOW_SIZE_ENV = 60 # Exemplo, pegue do config
+NUM_ASSETS=4
+WINDOW_SIZE=60
+
+NUM_FEATURES_PER_ASSET=26
+
+
+
+
+
+
+class PortfolioEnv(gym.Env): # Renomeado para seguir convenção de Gymnasium (Opcional)
+    metadata = {'render_modes': ['human'], 'render_fps': 30}
+
+    def __init__(self, df_multi_asset_features: pd.DataFrame, 
+                 asset_symbols_list: List[str], # Lista de chaves dos ativos ex: ['crypto_eth', 'stock_aapl']
+                 initial_balance=100000, 
+                 window_size=WINDOW_SIZE_ENV,
+                 transaction_cost_pct=0.001,
+                 reward_window_size=60, # Janela para cálculo do Sharpe Ratio (ex: 60 passos/horas)
+                 risk_free_rate_per_step=None): # Custo de transação de 0.1%
+        super(PortfolioEnv, self).__init__()
+        
+        self.df = df_multi_asset_features.copy() # DataFrame ACHATADO com todas as features de todos os ativos
+        self.asset_keys = asset_symbols_list # Usado para identificar colunas de preço de fechamento
+        self.num_assets = len(asset_symbols_list)
+        self.initial_balance = initial_balance
+        self.window_size = window_size
+        self.transaction_cost_pct = transaction_cost_pct
+        self.reward_window_size = reward_window_size
+        # Cálculo automático da taxa livre de risco por passo se não for passada
+        RISK_FREE_RATE_ANNUAL = 0.02 # 2% ao ano
+        TRADING_DAYS_PER_YEAR = 252
+        HOURS_PER_DAY_TRADING = 24
+        if risk_free_rate_per_step is None:
+            self.risk_free_rate_per_step = RISK_FREE_RATE_ANNUAL / (TRADING_DAYS_PER_YEAR * HOURS_PER_DAY_TRADING)
+        else:
+            self.risk_free_rate_per_step = risk_free_rate_per_step
+        self.portfolio_returns_history = deque(maxlen=self.reward_window_size) # Armazena retorenos do portifólio por passos
+        
+        self.current_step = 0
+        self.balance = self.initial_balance
+        self.portfolio_weights = np.full(self.num_assets, 1.0 / self.num_assets if self.num_assets > 0 else 0) # Pesos iniciais iguais
+        self.portfolio_value = self.initial_balance
+        self.total_steps = len(self.df) - self.window_size -2 # -1 para ter um next_prices
+
+        # Espaço de Ação: pesos do portfólio para cada ativo (devem somar 1, via Softmax da rede)
+        # A rede neural vai outputar pesos que somam 1 (softmax).
+        self.action_space = spaces.Box(low=0, high=1, shape=(NUM_ASSETS,), dtype=np.float32)
+        
+        # Espaço de Observação: janela de N features para M ativos (achatado)
+        # O número de colunas no df é num_assets * num_features_per_asset
+        num_total_features = self.df.shape[1]
+        self.observation_space = spaces.Box(
+            low=-np.inf, high=np.inf, 
+            shape=(WINDOW_SIZE, NUM_ASSETS * NUM_FEATURES_PER_ASSET), 
+            dtype=np.float32
+        )
+
+
+        
+        
+        self.current_prices_cols = [f"{key}_close" for key in self.asset_keys] # Assumindo que 'close' é uma das features base
+        # Se você usa 'close_div_atr', então seria f"{key}_close_div_atr"
+        # É importante ter uma coluna de preço de fechamento *original* (não escalada, não normalizada por ATR)
+        # para calcular os retornos reais do portfólio. Se não estiver no df, precisará ser adicionada/mantida.
+        # Por agora, vamos assumir que o df passado já tem as colunas de preço de fechamento originais,
+        # ou você precisará de um df separado só com os preços para o cálculo de retorno.
+        # VOU ASSUMIR QUE VOCÊ ADICIONA COLUNAS DE PREÇO DE FECHAMENTO ORIGINAIS AO `df_multi_asset_features`
+        # com nomes como `eth_orig_close`, `ada_orig_close` etc.
+        self.orig_close_price_cols = [f"{asset_prefix}_close" for asset_prefix in self.asset_keys] # Ex: 'crypto_eth_close'
+
+        # Verificar se as colunas de preço de fechamento original existem
+        missing_price_cols = [col for col in self.orig_close_price_cols if col not in self.df.columns]
+        if missing_price_cols:
+            raise ValueError(f"Colunas de preço de fechamento original ausentes no DataFrame do ambiente: {missing_price_cols}. "
+                             "Adicione-as ao DataFrame com prefixo do ativo (ex: 'crypto_eth_close').")
+
+
+    def _get_observation(self):
+        # Pega as features da janela atual
+        # O DataFrame self.df já deve estar achatado e conter TODAS as features de TODOS os ativos
+        start = self.current_step
+        end = start + self.window_size
+        obs = self.df.iloc[start:end].values
+        return obs.astype(np.float32)
+
+    def _get_current_prices(self):
+        # Pega os preços de fechamento originais do passo atual para cálculo de retorno
+        # O índice é window_size - 1 dentro da observação atual, que corresponde a self.current_step + self.window_size -1 no df original.
+        # Mas para o cálculo de PnL, precisamos do preço no início do step e no final do step.
+        # Preço no início do step (t)
+        return self.df[self.orig_close_price_cols].iloc[self.current_step + self.window_size -1].values
+
+    def _get_next_prices(self):
+        # Preço no final do step (t+1)
+        return self.df[self.orig_close_price_cols].iloc[self.current_step + self.window_size].values
+
+    def reset(self, seed=None, options=None): # Assinatura atualizada do Gymnasium
+        super().reset(seed=seed) # Importante para Gymnasium
+        self.current_step = 0 # Inicia do primeiro ponto onde uma janela completa pode ser formada
+        self.balance = self.initial_balance
+        self.portfolio_value = self.initial_balance
+        self.portfolio_weights = np.full(self.num_assets, 1.0 / self.num_assets if self.num_assets > 0 else 0)
+        self.portfolio_returns_history.clear()
+
+        observation = self._get_observation()
+        info = self._get_info() # Informações adicionais (opcional)
+        return observation, info
+    
+    def _calculate_sharpe_ratio(self) -> float:
+        """Calcula o Sharpe Ratio anualizado a partir do histórico de retornos por passo."""
+        if len(self.portfolio_returns_history) < self.reward_window_size / 2: # Precisa de um mínimo de dados
+            return 0.0 # Ou uma pequena penalidade por não ter histórico suficiente
+
+        returns_array = np.array(self.portfolio_returns_history)
+        
+        # Média dos retornos por passo
+        mean_return_per_step = np.mean(returns_array)
+        # Desvio padrão dos retornos por passo
+        std_return_per_step = np.std(returns_array)
+
+        print(f"    DEBUG Sharpe: mean_ret_step={mean_return_per_step:.6f}, std_ret_step={std_return_per_step:.6f}, risk_free_step={self.risk_free_rate_per_step:.8f}")
+
+        if std_return_per_step < 1e-9: # Evitar divisão por zero se não houver volatilidade
+            print("    DEBUG Sharpe: Std dev muito baixo, retornando 0.")
+            return 0.0 
+
+        # Sharpe Ratio por passo
+        sharpe_per_step = (mean_return_per_step - self.risk_free_rate_per_step) / std_return_per_step
+        
+        # Anualizar o Sharpe Ratio (assumindo passos horários e ~252 dias de negociação * 24 horas)
+        annualization_factor = np.sqrt(252 * 24) # Ajuste se seu timeframe for diferente
+        
+        annualized_sharpe = sharpe_per_step * annualization_factor
+        print(f"    DEBUG Sharpe: sharpe_per_step={sharpe_per_step:.4f}, annualized_sharpe={annualized_sharpe:.4f}")
+        return annualized_sharpe
+
+
+    def step(self, action_weights: np.ndarray): # Ação são os pesos do portfólio
+        current_portfolio_value_before_rebalance = self.portfolio_value
+
+        # Normalizar pesos da ação se não somarem 1 (saída softmax da rede já deve fazer isso)
+
+        if not np.isclose(np.sum(action_weights), 1.0):
+            action_weights = action_weights / (np.sum(action_weights) + 1e-9)
+        action_weights = np.clip(action_weights, 0, 1) # Garantir que os pesos estão entre 0 e 1 # Normaliza
+        
+        # Calcular custo de transação para rebalancear
+        # Valor de cada ativo ANTES do rebalanceamento
+        current_asset_values = self.portfolio_weights * current_portfolio_value_before_rebalance
+        # Valor de cada ativo DEPOIS do rebalanceamento (com base nos novos pesos)
+        target_asset_values = action_weights * current_portfolio_value_before_rebalance # Valor do portfólio ainda não mudou por preço
+
+        # Volume negociado (absoluto) para cada ativo
+        trade_volume_per_asset = np.abs(target_asset_values - current_asset_values)
+        total_trade_volume = np.sum(trade_volume_per_asset)
+        transaction_costs = total_trade_volume * self.transaction_cost_pct
+        
+        # Deduzir custos do valor do portfólio
+        current_portfolio_value_after_costs = current_portfolio_value_before_rebalance - transaction_costs
+        
+        # Atualizar os pesos do portfólio
+        self.portfolio_weights = action_weights
+        
+        # Pegar preços atuais (t) e próximos (t+1)
+        prices_t = self._get_current_prices()
+        self.current_step += 1 # Avançar para o próximo estado
+        prices_t_plus_1 = self._get_next_prices()
+
+        # Calcular retornos dos ativos
+        asset_returns_on_step = (prices_t_plus_1 - prices_t) / (prices_t + 1e-9)
+        
+        # Calcular retorno do portfólio neste passo, APÓS custos e com os NOVOS pesos
+        portfolio_return_on_step = np.sum(self.portfolio_weights * asset_returns_on_step)
+        
+        # Atualizar valor do portfólio
+        self.portfolio_value = current_portfolio_value_after_costs * (1 + portfolio_return_on_step)
+        
+        # Adicionar retorno do passo ao histórico
+        self.portfolio_returns_history.append(portfolio_return_on_step)
+        
+        # Calcular Recompensa (Sharpe Ratio)
+        # Pode ser o Sharpe Ratio incremental ou o Sharpe Ratio da janela inteira
+        # Para RL, uma recompensa mais frequente é geralmente melhor.
+        # Usar o retorno do passo como recompensa imediata pode ser mais estável para PPO.
+        # Ou, podemos dar o Sharpe Ratio da janela como recompensa a cada N passos, ou no final.
+        # Por agora, vamos usar o retorno do passo como recompensa principal, e o Sharpe pode ser parte do 'info'.
+        # Se quisermos o Sharpe Ratio *como* recompensa, ele seria calculado aqui.
+        
+        # Opção A: Recompensa = Retorno do Passo (mais simples e denso)
+        # ultima iteração   --  reward = portfolio_return_on_step   
+
+        #Opção B: Recompensa = Sharpe Ratio da Janela (mais complexo, pode ser esparso se calculado raramente)
+        # Em PortfolioEnv.step()
+# reward = portfolio_return_on_step # Recompensa atual
+
+# NOVA RECOMPENSA (Opção B da nossa discussão anterior):
+        REWARD_SCALE_FACTOR_SHARPE = 0.1  # Ou 0.01, experimente
+        if len(self.portfolio_returns_history) >= self.reward_window_size:
+            current_sharpe = self._calculate_sharpe_ratio()
+            reward = np.clip(current_sharpe, -5, 5) * REWARD_SCALE_FACTOR_SHARPE
+            print(f"  Sharpe Ratio Calculado: {current_sharpe:.4f}, Recompensa (Sharpe escalado): {reward:.6f}")
+        elif len(self.portfolio_returns_history) > 1:
+            reward = portfolio_return_on_step * 0.1
+            print(f"  Retorno Simples como Recompensa (escalado): {reward:.6f}")
+        else:
+            reward = 0.0
+
+        terminated = self.current_step >= self.total_steps 
+        truncated = False 
+
+        observation = self._get_observation()
+        info = self._get_info() # Adicionar Sharpe Ratio ao info
+
+        return observation, reward, terminated, truncated, info
+
+
+    def _get_info(self): # Opcional, para retornar métricas
+        current_sharpe = self._calculate_sharpe_ratio() if len(self.portfolio_returns_history) > 1 else 0.0
+        return {
+            "current_step": self.current_step,
+            "portfolio_value": self.portfolio_value,
+            "balance": self.balance, # Se você rastrear cash separadamente
+            "portfolio_weights": self.portfolio_weights.tolist(),
+            "last_step_return": self.portfolio_returns_history[-1] if self.portfolio_returns_history else 0.0,
+            "sharpe_ratio_window": current_sharpe
+        }
+
+    def render(self, mode='human'):
+        if mode == 'human':
+            print(f"Step: {self.current_step}, Portfolio Value: {self.portfolio_value:.2f}, Weights: {self.portfolio_weights}")
+
+    def close(self):
+        pass # Limpar recursos se necessário

agents/portfolio_features_extractor_torch.py

@@ -0,0 +1,35 @@
+import torch
+import torch.nn as nn
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor
+from deep_portfolio_torch import DeepPortfolioAgentNetworkTorch
+
+class PortfolioFeaturesExtractorTorch(BaseFeaturesExtractor):
+    def __init__(self, observation_space, features_dim=32,
+                 num_assets=4, sequence_length=60, num_features_per_asset=26,
+                 asset_cnn_filters1=32, asset_cnn_filters2=64,
+                 asset_lstm_units1=64, asset_lstm_units2=32,
+                 final_dense_units1=128, final_dense_units2=32,
+                 final_dropout=0.3, mha_num_heads=4, mha_key_dim_divisor=2,
+                 output_latent_features=True, use_sentiment_analysis=False):
+        super().__init__(observation_space, features_dim)
+        self.network = DeepPortfolioAgentNetworkTorch(
+            num_assets=num_assets,
+            sequence_length=sequence_length,
+            num_features_per_asset=num_features_per_asset,
+            asset_cnn_filters1=asset_cnn_filters1,
+            asset_cnn_filters2=asset_cnn_filters2,
+            asset_lstm_units1=asset_lstm_units1,
+            asset_lstm_units2=asset_lstm_units2,
+            final_dense_units1=final_dense_units1,
+            final_dense_units2=final_dense_units2,
+            final_dropout=final_dropout,
+            mha_num_heads=mha_num_heads,
+            mha_key_dim_divisor=mha_key_dim_divisor,
+            output_latent_features=output_latent_features,
+            use_sentiment_analysis=use_sentiment_analysis
+        )
+        self._features_dim = features_dim
+
+    def forward(self, observations):
+        # observations: (batch, seq_len, num_assets * num_features_per_asset)
+        return self.network(observations)

agents/ppo_deep_portfolio_tensorboard/PPO_1/events.out.tfevents.1750287361.verticalagent-X555LPB.89910.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:416a6f624b3dae44c64d6ad216c0d9c90927c65aa2fffc56dde39d387a66b0d2
+size 83375

agents/ppo_deep_portfolio_tensorboard/PPO_2/events.out.tfevents.1750321811.verticalagent-X555LPB.160180.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:554a8d430bd4a7a956b2166b588b07e2345511df984019982768a8bb199c83c8
+size 42785

agents/ppo_deep_portfolio_tensorboard/PPO_3/events.out.tfevents.1750336135.verticalagent-X555LPB.200649.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ee8dfec483892359b26ff8390f513acca25fc47bc447f47f82b2fc5eda2e014
+size 30977

agents/rl_agent.py

@@ -0,0 +1,9 @@
+# agents/rl_agent.py
+from stable_baselines3 import PPO
+from atcoin_env import TradingEnv  # custom env
+
+def train_rl_model():
+    env = TradingEnv()
+    model = PPO("MlpPolicy", env, verbose=1)
+    model.learn(total_timesteps=10000)
+    model.save("models/ppo_trading")

agents/train_agent_tfagents.py

@@ -0,0 +1,127 @@
+import tensorflow as tf
+import numpy as np
+from tf_agents.environments import tf_py_environment, wrappers, gym_wrapper
+from tf_agents.agents.ppo import ppo_agent
+from tf_agents.networks import actor_distribution_network, value_network
+from tf_agents.trajectories import trajectory
+from tf_agents.drivers.dynamic_step_driver import DynamicStepDriver
+from tf_agents.replay_buffers.tf_uniform_replay_buffer import TFUniformReplayBuffer
+from tf_agents.utils import common
+from tf_agents.metrics import tf_metrics
+from tensorflow.keras.optimizers import Adam
+
+# Seus módulos
+from portfolio_environment import PortfolioEnv  # Adaptado do seu código
+from DeepPortfolioAgent import DeepPortfolioAgentNetwork
+
+# --- CONFIGS ---
+NUM_ASSETS = 4
+WINDOW_SIZE = 60
+FEATURES_PER_ASSET = 26
+TOTAL_FEATURES = NUM_ASSETS * FEATURES_PER_ASSET
+BATCH_SIZE = 64
+REPLAY_BUFFER_CAPACITY = 1000
+LEARNING_RATE = 3e-4
+NUM_ITERATIONS = 200
+
+import pandas as pd
+
+# Mock: gera dados aleatórios para teste
+num_steps = 500
+symbols = ["ETH-USD","BTC-USD","ADA-USD","SOL-USD"]
+features = ["open", "high", "low", "close", "volume"]
+df_data = {}
+
+for symbol in symbols:
+    for feat in features:
+        df_data[f"{symbol}_{feat}"] = np.random.rand(num_steps)
+
+df_mock = pd.DataFrame(df_data)
+
+
+# --- ENV SETUP ---
+py_env = PortfolioEnv(df_mock, asset_symbols_list=symbols)
+train_env = tf_py_environment.TFPyEnvironment(gym_wrapper.GymWrapper(py_env))
+
+# --- FEATURE EXTRACTOR WRAPPER ---
+class FeatureProjector(tf.keras.Model):
+    def __init__(self):
+        super().__init__()
+        self.extractor = DeepPortfolioAgentNetwork(
+            num_assets=NUM_ASSETS,
+            sequence_length=WINDOW_SIZE,
+            num_features_per_asset=FEATURES_PER_ASSET,
+            asset_cnn_filters1=32,
+            asset_cnn_filters2=64,
+            asset_lstm_units1=64,
+            asset_lstm_units2=32,
+            mha_num_heads=4,
+            mha_key_dim_divisor=4,
+            final_dense_units1=64,
+            final_dense_units2=32,
+            final_dropout=0.2,
+            use_sentiment_analysis=False
+        )
+
+    def call(self, observation, training=False):
+        return self.extractor(observation, training=training)
+
+# --- NETWORKS ---
+feature_combiner = FeatureProjector()
+
+actor_net = actor_distribution_network.ActorDistributionNetwork(
+    input_tensor_spec=train_env.observation_spec(),
+    output_tensor_spec=train_env.action_spec(),
+    preprocessing_combiner=feature_combiner,
+    fc_layer_params=()
+)
+
+value_net = value_network.ValueNetwork(
+    input_tensor_spec=train_env.observation_spec(),
+    preprocessing_combiner=feature_combiner,
+    fc_layer_params=()
+)
+
+# --- AGENT ---
+optimizer = Adam(learning_rate=LEARNING_RATE)
+train_step = tf.Variable(0)
+agent = ppo_agent.PPOAgent(
+    train_env.time_step_spec(),
+    train_env.action_spec(),
+    actor_net=actor_net,
+    value_net=value_net,
+    optimizer=optimizer,
+    num_epochs=5,
+    train_step_counter=train_step
+)
+agent.initialize()
+
+# --- REPLAY BUFFER ---
+replay_buffer = TFUniformReplayBuffer(
+    data_spec=agent.collect_data_spec,
+    batch_size=train_env.batch_size,
+    max_length=REPLAY_BUFFER_CAPACITY
+)
+
+# --- DRIVER ---
+observer = replay_buffer.add_batch
+driver = DynamicStepDriver(
+    env=train_env,
+    policy=agent.collect_policy,
+    observers=[observer],
+    num_steps=1
+)
+
+# --- METRICS (opcional) ---
+avg_return = tf_metrics.AverageReturnMetric()
+
+# --- TREINAMENTO ---
+print("🚦 Iniciando ciclo de treino PPO com TFAgents e DeepPortfolioAgentNetwork...")
+for i in range(NUM_ITERATIONS):
+    driver.run()
+    experience = replay_buffer.gather_all()
+    train_loss = agent.train(experience)
+    replay_buffer.clear()
+    print(f"Iteração {i+1}/{NUM_ITERATIONS} - Loss: {train_loss.loss:.5f}")
+
+print("✅ Treinamento finalizado com sucesso!")

agents/train_rl_portfolio_agent.py

@@ -0,0 +1,755 @@
+# train_rl_portfolio_agent.py
+from stable_baselines3 import PPO
+from stable_baselines3.common.env_checker import check_env
+#from transformers import logger
+
+# rnn/agents/custom_policies.py (NOVO ARQUIVO, ou adicione ao deep_portfolio.py)
+
+import gymnasium as gym # Usar gymnasium
+import tensorflow as tf
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor as PyTorchBaseFeaturesExtractor
+
+from stable_baselines3.common.torch_layers import MlpExtractor
+import torch.nn as nn
+
+class CustomMlpExtractor(MlpExtractor):
+    def __init__(self, input_dim, net_arch, activation_fn, device):
+        super().__init__(input_dim, net_arch, activation_fn, device)
+
+    def forward(self, features):
+        for layer in self.policy_net:
+            if isinstance(layer, nn.ReLU):
+                features = layer(features)  # Passando 'features' como argumento
+            else:
+                features = layer(features)
+        return features
+# Para TensorFlow, precisamos de um extrator de features compatível ou construir a política de forma diferente.
+# Stable Baselines3 tem melhor suporte nativo para PyTorch. Para TF, é um pouco mais manual.
+# VAMOS USAR A ABORDAGEM DE POLÍTICA CUSTOMIZADA COM TF DIRETAMENTE.
+from stable_baselines3.common.policies import ActorCriticPolicy
+from typing import List, Dict, Any, Optional, Union, Type
+# Importar sua rede e configs
+#import agents.DeepPortfolioAgent as DeepPortfolioAgent
+from DeepPortfolioAgent import DeepPortfolioAgentNetwork 
+# from ..config import (NUM_ASSETS, WINDOW_SIZE, NUM_FEATURES_PER_ASSET, ...) # Importe do seu config real
+# VALORES DE EXEMPLO (PEGUE DO SEU CONFIG.PY REAL)
+NUM_ASSETS_POLICY = 4
+WINDOW_SIZE_POLICY = 60
+NUM_FEATURES_PER_ASSET_POLICY = 26
+# Hiperparâmetros para DeepPortfolioAgentNetwork quando usada como extrator
+ASSET_CNN_FILTERS1_POLICY = 32
+ASSET_CNN_FILTERS2_POLICY = 64
+ASSET_LSTM_UNITS1_POLICY = 64
+ASSET_LSTM_UNITS2_POLICY = 32 # Esta será a dimensão das features latentes para ator/crítico
+ASSET_DROPOUT_POLICY = 0.2
+MHA_NUM_HEADS_POLICY = 4
+MHA_KEY_DIM_DIVISOR_POLICY = 2 # Para key_dim = 32 // 2 = 16
+FINAL_DENSE_UNITS1_POLICY = 128
+FINAL_DENSE_UNITS2_POLICY = ASSET_LSTM_UNITS2_POLICY # A saída da dense2 SÃO as features latentes
+FINAL_DROPOUT_POLICY = 0.3
+
+
+class TFPortfolioFeaturesExtractor(tf.keras.layers.Layer): # Herda de tf.keras.layers.Layer
+    """
+    Extrator de features customizado para SB3 que usa DeepPortfolioAgentNetwork.
+    A observação do ambiente é (batch, window, num_assets * num_features_per_asset).
+    A saída são as features latentes (batch, latent_dim).
+    """
+    def __init__(self, observation_space: gym.spaces.Box, features_dim: int = ASSET_LSTM_UNITS2_POLICY):
+        super(TFPortfolioFeaturesExtractor, self).__init__()
+        self.features_dim = features_dim # SB3 usa isso para saber o tamanho da saída
+
+        # Instanciar a rede base para extrair features
+        # Ela deve retornar as ativações ANTES da camada softmax de alocação.
+        self.network = DeepPortfolioAgentNetwork(
+            num_assets=NUM_ASSETS_POLICY,
+            sequence_length=WINDOW_SIZE_POLICY,
+            num_features_per_asset=NUM_FEATURES_PER_ASSET_POLICY,
+            asset_cnn_filters1=ASSET_CNN_FILTERS1_POLICY, 
+            asset_cnn_filters2=ASSET_CNN_FILTERS2_POLICY,
+            asset_lstm_units1=ASSET_LSTM_UNITS1_POLICY, 
+            asset_lstm_units2=ASSET_LSTM_UNITS2_POLICY, # Define a saída do asset_processor
+            asset_dropout=ASSET_DROPOUT_POLICY,
+            mha_num_heads=MHA_NUM_HEADS_POLICY, 
+            mha_key_dim_divisor=MHA_KEY_DIM_DIVISOR_POLICY,
+            final_dense_units1=FINAL_DENSE_UNITS1_POLICY, 
+            final_dense_units2=self.features_dim, # A saída da dense2 é a nossa feature latente
+            final_dropout=FINAL_DROPOUT_POLICY,
+            output_latent_features=True,
+            use_sentiment_analysis=True # MUITO IMPORTANTE!
+        )
+        print("TFPortfolioFeaturesExtractor inicializado e usando DeepPortfolioAgentNetwork (output_latent_features=True).")
+
+    def call(self, observations: tf.Tensor, training: bool = False) -> tf.Tensor:
+        # A DeepPortfolioAgentNetwork já lida com o fatiamento e processamento.
+        # Ela foi configurada para retornar features latentes.
+        return self.network(observations, training=training)
+
+
+class CustomPolicy(ActorCriticPolicy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mlp_extractor = CustomMlpExtractor(
+            input_dim=self.observation_space.shape[0],
+            net_arch=[64, 64],  # Exemplo de arquitetura
+            activation_fn=nn.ReLU,
+            device=self.device
+        )
+
+
+
+class CustomPortfolioPolicySB3(ActorCriticPolicy):
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule, # Função que retorna a taxa de aprendizado
+        net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None, # Arquitetura para MLPs pós-extrator
+        activation_fn: Type[tf.Module] = tf.nn.relu, # Usar tf.nn.relu para TF
+        # Adicionar quaisquer outros parâmetros específicos que o extrator precise
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        if features_extractor_kwargs is None:
+            features_extractor_kwargs = {}
+        
+        # A dimensão das features que o nosso extrator PortfolioFeatureExtractor vai cuspir.
+        # Deve ser igual a ASSET_LSTM_UNITS2_POLICY (ou final_dense_units2 do extrator)
+        # Se não for passado, o construtor do ActorCriticPolicy pode tentar inferir.
+        # Vamos passar explicitamente para garantir.
+        features_extractor_kwargs.setdefault("features_dim", ASSET_LSTM_UNITS2_POLICY) # Ou o valor que você definiu
+
+        super().__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch=net_arch, # Para camadas Dense APÓS o extrator de features
+            activation_fn=activation_fn,
+            features_extractor_class=TFPortfolioFeaturesExtractor,
+            features_extractor_kwargs=features_extractor_kwargs,
+            **kwargs,
+        )
+        # Otimizador é criado na classe base.
+        # As redes de ator e crítico são construídas no método _build da classe base,
+        # usando o self.features_extractor e depois o self.mlp_extractor (que é
+        # construído com base no net_arch).
+
+    # Não precisamos sobrescrever _build_mlp_extractor se o features_extractor
+    # já fizer o trabalho pesado e o net_arch padrão para as cabeças for suficiente.
+    # Se quisermos MLPs customizados para ator e crítico APÓS o extrator:
+    # def _build_mlp_extractor(self) -> None:
+    #     # self.mlp_extractor é uma instância de MlpExtractor (ou similar)
+    #     # A entrada para ele é self.features_extractor.features_dim
+    #     # Aqui, net_arch definiria a estrutura do mlp_extractor
+    #     self.mlp_extractor = MlpExtractor(
+    #         feature_dim=self.features_extractor.features_dim,
+    #         net_arch=self.net_arch, # net_arch é uma lista de ints para camadas da política e valor
+    #         activation_fn=self.activation_fn,
+    #         device=self.device,
+    #     )
+    # As redes de ação e valor (action_net, value_net) são então criadas
+    # no _build da classe ActorCriticPolicy, no topo do mlp_extractor.# rnn/agents/custom_policies.py (NOVO ARQUIVO, ou adicione ao deep_portfolio.py)
+
+import gymnasium as gym # Usar gymnasium
+import tensorflow as tf
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor as PyTorchBaseFeaturesExtractor
+
+from stable_baselines3.common.torch_layers import MlpExtractor
+import torch.nn as nn
+
+class CustomMlpExtractor(MlpExtractor):
+    def __init__(self, input_dim, net_arch, activation_fn, device):
+        super().__init__(input_dim, net_arch, activation_fn, device)
+
+    def forward(self, features):
+        for layer in self.policy_net:
+            if isinstance(layer, nn.ReLU):
+                features = layer(features)  # Passando 'features' como argumento
+            else:
+                features = layer(features)
+        return features
+# Para TensorFlow, precisamos de um extrator de features compatível ou construir a política de forma diferente.
+# Stable Baselines3 tem melhor suporte nativo para PyTorch. Para TF, é um pouco mais manual.
+# VAMOS USAR A ABORDAGEM DE POLÍTICA CUSTOMIZADA COM TF DIRETAMENTE.
+from stable_baselines3.common.policies import ActorCriticPolicy
+from typing import List, Dict, Any, Optional, Union, Type
+# Importar sua rede e configs
+#import agents.DeepPortfolioAgent as DeepPortfolioAgent
+from DeepPortfolioAgent import DeepPortfolioAgentNetwork 
+# from ..config import (NUM_ASSETS, WINDOW_SIZE, NUM_FEATURES_PER_ASSET, ...) # Importe do seu config real
+# VALORES DE EXEMPLO (PEGUE DO SEU CONFIG.PY REAL)
+NUM_ASSETS_POLICY = 4
+WINDOW_SIZE_POLICY = 60
+NUM_FEATURES_PER_ASSET_POLICY = 26
+# Hiperparâmetros para DeepPortfolioAgentNetwork quando usada como extrator
+ASSET_CNN_FILTERS1_POLICY = 32
+ASSET_CNN_FILTERS2_POLICY = 64
+ASSET_LSTM_UNITS1_POLICY = 64
+ASSET_LSTM_UNITS2_POLICY = 32 # Esta será a dimensão das features latentes para ator/crítico
+ASSET_DROPOUT_POLICY = 0.2
+MHA_NUM_HEADS_POLICY = 4
+MHA_KEY_DIM_DIVISOR_POLICY = 2 # Para key_dim = 32 // 2 = 16
+FINAL_DENSE_UNITS1_POLICY = 128
+FINAL_DENSE_UNITS2_POLICY = ASSET_LSTM_UNITS2_POLICY # A saída da dense2 SÃO as features latentes
+FINAL_DROPOUT_POLICY = 0.3
+
+
+class TFPortfolioFeaturesExtractor(tf.keras.layers.Layer): # Herda de tf.keras.layers.Layer
+    """
+    Extrator de features customizado para SB3 que usa DeepPortfolioAgentNetwork.
+    A observação do ambiente é (batch, window, num_assets * num_features_per_asset).
+    A saída são as features latentes (batch, latent_dim).
+    """
+    def __init__(self, observation_space: gym.spaces.Box, features_dim: int = ASSET_LSTM_UNITS2_POLICY):
+        super(TFPortfolioFeaturesExtractor, self).__init__()
+        self.features_dim = features_dim # SB3 usa isso para saber o tamanho da saída
+
+        # Instanciar a rede base para extrair features
+        # Ela deve retornar as ativações ANTES da camada softmax de alocação.
+        self.network = DeepPortfolioAgentNetwork(
+            num_assets=NUM_ASSETS_POLICY,
+            sequence_length=WINDOW_SIZE_POLICY,
+            num_features_per_asset=NUM_FEATURES_PER_ASSET_POLICY,
+            asset_cnn_filters1=ASSET_CNN_FILTERS1_POLICY, 
+            asset_cnn_filters2=ASSET_CNN_FILTERS2_POLICY,
+            asset_lstm_units1=ASSET_LSTM_UNITS1_POLICY, 
+            asset_lstm_units2=ASSET_LSTM_UNITS2_POLICY, # Define a saída do asset_processor
+            asset_dropout=ASSET_DROPOUT_POLICY,
+            mha_num_heads=MHA_NUM_HEADS_POLICY, 
+            mha_key_dim_divisor=MHA_KEY_DIM_DIVISOR_POLICY,
+            final_dense_units1=FINAL_DENSE_UNITS1_POLICY, 
+            final_dense_units2=self.features_dim, # A saída da dense2 é a nossa feature latente
+            final_dropout=FINAL_DROPOUT_POLICY,
+            output_latent_features=True,
+            use_sentiment_analysis=True # MUITO IMPORTANTE!
+        )
+        print("TFPortfolioFeaturesExtractor inicializado e usando DeepPortfolioAgentNetwork (output_latent_features=True).")
+
+    def call(self, observations: tf.Tensor, training: bool = False) -> tf.Tensor:
+        # A DeepPortfolioAgentNetwork já lida com o fatiamento e processamento.
+        # Ela foi configurada para retornar features latentes.
+        return self.network(observations, training=training)
+
+
+class CustomPolicy(ActorCriticPolicy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mlp_extractor = CustomMlpExtractor(
+            input_dim=self.observation_space.shape[0],
+            net_arch=[64, 64],  # Exemplo de arquitetura
+            activation_fn=nn.ReLU,
+            device=self.device
+        )
+
+
+
+class CustomPortfolioPolicySB3(ActorCriticPolicy):
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule, # Função que retorna a taxa de aprendizado
+        net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None, # Arquitetura para MLPs pós-extrator
+        activation_fn: Type[tf.Module] = tf.nn.relu, # Usar tf.nn.relu para TF
+        # Adicionar quaisquer outros parâmetros específicos que o extrator precise
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        if features_extractor_kwargs is None:
+            features_extractor_kwargs = {}
+        
+        # A dimensão das features que o nosso extrator PortfolioFeatureExtractor vai cuspir.
+        # Deve ser igual a ASSET_LSTM_UNITS2_POLICY (ou final_dense_units2 do extrator)
+        # Se não for passado, o construtor do ActorCriticPolicy pode tentar inferir.
+        # Vamos passar explicitamente para garantir.
+        features_extractor_kwargs.setdefault("features_dim", ASSET_LSTM_UNITS2_POLICY) # Ou o valor que você definiu
+
+        super().__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch=net_arch, # Para camadas Dense APÓS o extrator de features
+            activation_fn=activation_fn,
+            features_extractor_class=TFPortfolioFeaturesExtractor,
+            features_extractor_kwargs=features_extractor_kwargs,
+            **kwargs,
+        )
+        # Otimizador é criado na classe base.
+        # As redes de ator e crítico são construídas no método _build da classe base,
+        # usando o self.features_extractor e depois o self.mlp_extractor (que é
+        # construído com base no net_arch).
+
+    # Não precisamos sobrescrever _build_mlp_extractor se o features_extractor
+    # já fizer o trabalho pesado e o net_arch padrão para as cabeças for suficiente.
+    # Se quisermos MLPs customizados para ator e crítico APÓS o extrator:
+    # def _build_mlp_extractor(self) -> None:
+    #     # self.mlp_extractor é uma instância de MlpExtractor (ou similar)
+    #     # A entrada para ele é self.features_extractor.features_dim
+    #     # Aqui, net_arch definiria a estrutura do mlp_extractor
+    #     self.mlp_extractor = MlpExtractor(
+    #         feature_dim=self.features_extractor.features_dim,
+    #         net_arch=self.net_arch, # net_arch é uma lista de ints para camadas da política e valor
+    #         activation_fn=self.activation_fn,
+    #         device=self.device,
+    #     )
+    # As redes de ação e valor (action_net, value_net) são então criadas
+    # no _build da classe ActorCriticPolicy, no topo do mlp_extractor.# rnn/agents/custom_policies.py (NOVO ARQUIVO, ou adicione ao deep_portfolio.py)
+
+import gymnasium as gym # Usar gymnasium
+import tensorflow as tf
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor as PyTorchBaseFeaturesExtractor
+
+from stable_baselines3.common.torch_layers import MlpExtractor
+import torch.nn as nn
+
+class CustomMlpExtractor(MlpExtractor):
+    def __init__(self, input_dim, net_arch, activation_fn, device):
+        super().__init__(input_dim, net_arch, activation_fn, device)
+
+    def forward(self, features):
+        for layer in self.policy_net:
+            if isinstance(layer, nn.ReLU):
+                features = layer(features)  # Passando 'features' como argumento
+            else:
+                features = layer(features)
+        return features
+# Para TensorFlow, precisamos de um extrator de features compatível ou construir a política de forma diferente.
+# Stable Baselines3 tem melhor suporte nativo para PyTorch. Para TF, é um pouco mais manual.
+# VAMOS USAR A ABORDAGEM DE POLÍTICA CUSTOMIZADA COM TF DIRETAMENTE.
+from stable_baselines3.common.policies import ActorCriticPolicy
+from typing import List, Dict, Any, Optional, Union, Type
+# Importar sua rede e configs
+#import agents.DeepPortfolioAgent as DeepPortfolioAgent
+from DeepPortfolioAgent import DeepPortfolioAgentNetwork 
+# from ..config import (NUM_ASSETS, WINDOW_SIZE, NUM_FEATURES_PER_ASSET, ...) # Importe do seu config real
+# VALORES DE EXEMPLO (PEGUE DO SEU CONFIG.PY REAL)
+NUM_ASSETS_POLICY = 4
+WINDOW_SIZE_POLICY = 60
+NUM_FEATURES_PER_ASSET_POLICY = 26
+# Hiperparâmetros para DeepPortfolioAgentNetwork quando usada como extrator
+ASSET_CNN_FILTERS1_POLICY = 32
+ASSET_CNN_FILTERS2_POLICY = 64
+ASSET_LSTM_UNITS1_POLICY = 64
+ASSET_LSTM_UNITS2_POLICY = 32 # Esta será a dimensão das features latentes para ator/crítico
+ASSET_DROPOUT_POLICY = 0.2
+MHA_NUM_HEADS_POLICY = 4
+MHA_KEY_DIM_DIVISOR_POLICY = 2 # Para key_dim = 32 // 2 = 16
+FINAL_DENSE_UNITS1_POLICY = 128
+FINAL_DENSE_UNITS2_POLICY = ASSET_LSTM_UNITS2_POLICY # A saída da dense2 SÃO as features latentes
+FINAL_DROPOUT_POLICY = 0.3
+
+
+class TFPortfolioFeaturesExtractor(tf.keras.layers.Layer): # Herda de tf.keras.layers.Layer
+    """
+    Extrator de features customizado para SB3 que usa DeepPortfolioAgentNetwork.
+    A observação do ambiente é (batch, window, num_assets * num_features_per_asset).
+    A saída são as features latentes (batch, latent_dim).
+    """
+    def __init__(self, observation_space: gym.spaces.Box, features_dim: int = ASSET_LSTM_UNITS2_POLICY):
+        super(TFPortfolioFeaturesExtractor, self).__init__()
+        self.features_dim = features_dim # SB3 usa isso para saber o tamanho da saída
+
+        # Instanciar a rede base para extrair features
+        # Ela deve retornar as ativações ANTES da camada softmax de alocação.
+        self.network = DeepPortfolioAgentNetwork(
+            num_assets=NUM_ASSETS_POLICY,
+            sequence_length=WINDOW_SIZE_POLICY,
+            num_features_per_asset=NUM_FEATURES_PER_ASSET_POLICY,
+            asset_cnn_filters1=ASSET_CNN_FILTERS1_POLICY, 
+            asset_cnn_filters2=ASSET_CNN_FILTERS2_POLICY,
+            asset_lstm_units1=ASSET_LSTM_UNITS1_POLICY, 
+            asset_lstm_units2=ASSET_LSTM_UNITS2_POLICY, # Define a saída do asset_processor
+            asset_dropout=ASSET_DROPOUT_POLICY,
+            mha_num_heads=MHA_NUM_HEADS_POLICY, 
+            mha_key_dim_divisor=MHA_KEY_DIM_DIVISOR_POLICY,
+            final_dense_units1=FINAL_DENSE_UNITS1_POLICY, 
+            final_dense_units2=self.features_dim, # A saída da dense2 é a nossa feature latente
+            final_dropout=FINAL_DROPOUT_POLICY,
+            output_latent_features=True,
+            use_sentiment_analysis=True # MUITO IMPORTANTE!
+        )
+        print("TFPortfolioFeaturesExtractor inicializado e usando DeepPortfolioAgentNetwork (output_latent_features=True).")
+
+    def call(self, observations: tf.Tensor, training: bool = False) -> tf.Tensor:
+        # A DeepPortfolioAgentNetwork já lida com o fatiamento e processamento.
+        # Ela foi configurada para retornar features latentes.
+        return self.network(observations, training=training)
+
+
+class CustomPolicy(ActorCriticPolicy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mlp_extractor = CustomMlpExtractor(
+            input_dim=self.observation_space.shape[0],
+            net_arch=[64, 64],  # Exemplo de arquitetura
+            activation_fn=nn.ReLU,
+            device=self.device
+        )
+
+
+
+class CustomPortfolioPolicySB3(ActorCriticPolicy):
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule, # Função que retorna a taxa de aprendizado
+        net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None, # Arquitetura para MLPs pós-extrator
+        activation_fn: Type[tf.Module] = tf.nn.relu, # Usar tf.nn.relu para TF
+        # Adicionar quaisquer outros parâmetros específicos que o extrator precise
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        if features_extractor_kwargs is None:
+            features_extractor_kwargs = {}
+        
+        # A dimensão das features que o nosso extrator PortfolioFeatureExtractor vai cuspir.
+        # Deve ser igual a ASSET_LSTM_UNITS2_POLICY (ou final_dense_units2 do extrator)
+        # Se não for passado, o construtor do ActorCriticPolicy pode tentar inferir.
+        # Vamos passar explicitamente para garantir.
+        features_extractor_kwargs.setdefault("features_dim", ASSET_LSTM_UNITS2_POLICY) # Ou o valor que você definiu
+
+        super().__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch=net_arch, # Para camadas Dense APÓS o extrator de features
+            activation_fn=activation_fn,
+            features_extractor_class=TFPortfolioFeaturesExtractor,
+            features_extractor_kwargs=features_extractor_kwargs,
+            **kwargs,
+        )
+        # Otimizador é criado na classe base.
+        # As redes de ator e crítico são construídas no método _build da classe base,
+        # usando o self.features_extractor e depois o self.mlp_extractor (que é
+        # construído com base no net_arch).
+
+    # Não precisamos sobrescrever _build_mlp_extractor se o features_extractor
+    # já fizer o trabalho pesado e o net_arch padrão para as cabeças for suficiente.
+    # Se quisermos MLPs customizados para ator e crítico APÓS o extrator:
+    # def _build_mlp_extractor(self) -> None:
+    #     # self.mlp_extractor é uma instância de MlpExtractor (ou similar)
+    #     # A entrada para ele é self.features_extractor.features_dim
+    #     # Aqui, net_arch definiria a estrutura do mlp_extractor
+    #     self.mlp_extractor = MlpExtractor(
+    #         feature_dim=self.features_extractor.features_dim,
+    #         net_arch=self.net_arch, # net_arch é uma lista de ints para camadas da política e valor
+    #         activation_fn=self.activation_fn,
+    #         device=self.device,
+    #     )
+    # As redes de ação e valor (action_net, value_net) são então criadas
+    # no _build da classe ActorCriticPolicy, no topo do mlp_extractor.# rnn/agents/custom_policies.py (NOVO ARQUIVO, ou adicione ao deep_portfolio.py)
+
+import gymnasium as gym # Usar gymnasium
+import tensorflow as tf
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor as PyTorchBaseFeaturesExtractor
+
+from stable_baselines3.common.torch_layers import MlpExtractor
+import torch.nn as nn
+
+class CustomMlpExtractor(MlpExtractor):
+    def __init__(self, input_dim, net_arch, activation_fn, device):
+        super().__init__(input_dim, net_arch, activation_fn, device)
+
+    def forward(self, features):
+        for layer in self.policy_net:
+            if isinstance(layer, nn.ReLU):
+                features = layer(features)  # Passando 'features' como argumento
+            else:
+                features = layer(features)
+        return features
+# Para TensorFlow, precisamos de um extrator de features compatível ou construir a política de forma diferente.
+# Stable Baselines3 tem melhor suporte nativo para PyTorch. Para TF, é um pouco mais manual.
+# VAMOS USAR A ABORDAGEM DE POLÍTICA CUSTOMIZADA COM TF DIRETAMENTE.
+from stable_baselines3.common.policies import ActorCriticPolicy
+from typing import List, Dict, Any, Optional, Union, Type
+# Importar sua rede e configs
+#import agents.DeepPortfolioAgent as DeepPortfolioAgent
+from DeepPortfolioAgent import DeepPortfolioAgentNetwork 
+# from ..config import (NUM_ASSETS, WINDOW_SIZE, NUM_FEATURES_PER_ASSET, ...) # Importe do seu config real
+# VALORES DE EXEMPLO (PEGUE DO SEU CONFIG.PY REAL)
+NUM_ASSETS_POLICY = 4
+WINDOW_SIZE_POLICY = 60
+NUM_FEATURES_PER_ASSET_POLICY = 26
+# Hiperparâmetros para DeepPortfolioAgentNetwork quando usada como extrator
+ASSET_CNN_FILTERS1_POLICY = 32
+ASSET_CNN_FILTERS2_POLICY = 64
+ASSET_LSTM_UNITS1_POLICY = 64
+ASSET_LSTM_UNITS2_POLICY = 32 # Esta será a dimensão das features latentes para ator/crítico
+ASSET_DROPOUT_POLICY = 0.2
+MHA_NUM_HEADS_POLICY = 4
+MHA_KEY_DIM_DIVISOR_POLICY = 2 # Para key_dim = 32 // 2 = 16
+FINAL_DENSE_UNITS1_POLICY = 128
+FINAL_DENSE_UNITS2_POLICY = ASSET_LSTM_UNITS2_POLICY # A saída da dense2 SÃO as features latentes
+FINAL_DROPOUT_POLICY = 0.3
+
+
+class TFPortfolioFeaturesExtractor(tf.keras.layers.Layer): # Herda de tf.keras.layers.Layer
+    """
+    Extrator de features customizado para SB3 que usa DeepPortfolioAgentNetwork.
+    A observação do ambiente é (batch, window, num_assets * num_features_per_asset).
+    A saída são as features latentes (batch, latent_dim).
+    """
+    def __init__(self, observation_space: gym.spaces.Box, features_dim: int = ASSET_LSTM_UNITS2_POLICY):
+        super(TFPortfolioFeaturesExtractor, self).__init__()
+        self.features_dim = features_dim # SB3 usa isso para saber o tamanho da saída
+
+        # Instanciar a rede base para extrair features
+        # Ela deve retornar as ativações ANTES da camada softmax de alocação.
+        self.network = DeepPortfolioAgentNetwork(
+            num_assets=NUM_ASSETS_POLICY,
+            sequence_length=WINDOW_SIZE_POLICY,
+            num_features_per_asset=NUM_FEATURES_PER_ASSET_POLICY,
+            asset_cnn_filters1=ASSET_CNN_FILTERS1_POLICY, 
+            asset_cnn_filters2=ASSET_CNN_FILTERS2_POLICY,
+            asset_lstm_units1=ASSET_LSTM_UNITS1_POLICY, 
+            asset_lstm_units2=ASSET_LSTM_UNITS2_POLICY, # Define a saída do asset_processor
+            asset_dropout=ASSET_DROPOUT_POLICY,
+            mha_num_heads=MHA_NUM_HEADS_POLICY, 
+            mha_key_dim_divisor=MHA_KEY_DIM_DIVISOR_POLICY,
+            final_dense_units1=FINAL_DENSE_UNITS1_POLICY, 
+            final_dense_units2=self.features_dim, # A saída da dense2 é a nossa feature latente
+            final_dropout=FINAL_DROPOUT_POLICY,
+            output_latent_features=True,
+            use_sentiment_analysis=True # MUITO IMPORTANTE!
+        )
+        print("TFPortfolioFeaturesExtractor inicializado e usando DeepPortfolioAgentNetwork (output_latent_features=True).")
+
+    def call(self, observations: tf.Tensor, training: bool = False) -> tf.Tensor:
+        # A DeepPortfolioAgentNetwork já lida com o fatiamento e processamento.
+        # Ela foi configurada para retornar features latentes.
+        return self.network(observations, training=training)
+
+
+class CustomPolicy(ActorCriticPolicy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mlp_extractor = CustomMlpExtractor(
+            input_dim=self.observation_space.shape[0],
+            net_arch=[64, 64],  # Exemplo de arquitetura
+            activation_fn=nn.ReLU,
+            device=self.device
+        )
+
+
+
+class CustomPortfolioPolicySB3(ActorCriticPolicy):
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule, # Função que retorna a taxa de aprendizado
+        net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None, # Arquitetura para MLPs pós-extrator
+        activation_fn: Type[tf.Module] = tf.nn.relu, # Usar tf.nn.relu para TF
+        # Adicionar quaisquer outros parâmetros específicos que o extrator precise
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        if features_extractor_kwargs is None:
+            features_extractor_kwargs = {}
+        
+        # A dimensão das features que o nosso extrator PortfolioFeatureExtractor vai cuspir.
+        # Deve ser igual a ASSET_LSTM_UNITS2_POLICY (ou final_dense_units2 do extrator)
+        # Se não for passado, o construtor do ActorCriticPolicy pode tentar inferir.
+        # Vamos passar explicitamente para garantir.
+        features_extractor_kwargs.setdefault("features_dim", ASSET_LSTM_UNITS2_POLICY) # Ou o valor que você definiu
+
+        super().__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch=net_arch, # Para camadas Dense APÓS o extrator de features
+            activation_fn=activation_fn,
+            features_extractor_class=TFPortfolioFeaturesExtractor,
+            features_extractor_kwargs=features_extractor_kwargs,
+            **kwargs,
+        )
+        # Otimizador é criado na classe base.
+        # As redes de ator e crítico são construídas no método _build da classe base,
+        # usando o self.features_extractor e depois o self.mlp_extractor (que é
+        # construído com base no net_arch).
+
+    # Não precisamos sobrescrever _build_mlp_extractor se o features_extractor
+    # já fizer o trabalho pesado e o net_arch padrão para as cabeças for suficiente.
+    # Se quisermos MLPs customizados para ator e crítico APÓS o extrator:
+    # def _build_mlp_extractor(self) -> None:
+    #     # self.mlp_extractor é uma instância de MlpExtractor (ou similar)
+    #     # A entrada para ele é self.features_extractor.features_dim
+    #     # Aqui, net_arch definiria a estrutura do mlp_extractor
+    #     self.mlp_extractor = MlpExtractor(
+    #         feature_dim=self.features_extractor.features_dim,
+    #         net_arch=self.net_arch, # net_arch é uma lista de ints para camadas da política e valor
+    #         activation_fn=self.activation_fn,
+    #         device=self.device,
+    #     )
+    # As redes de ação e valor (action_net, value_net) são então criadas
+    # no _build da classe ActorCriticPolicy, no topo do mlp_extractor.
+
+from custom_policies import CustomPortfolioPolicySB3 # Importar a política customizada
+#from .deep_portfolio import NUM_ASSETS_CONF, WINDOW_SIZE_CONF, NUM_FEATURES_PER_ASSET_CONF # Se precisar para policy_kwargs
+# (Importe as configs do config.py)
+#from ..config import LEARNING_RATE as PPO_LEARNING_RATE 
+PPO_LEARNING_RATE = 0.0005
+
+
+from data_handler_multi_asset import get_multi_asset_data_for_rl, MULTI_ASSET_SYMBOLS # Do seu config/data_handler
+from portfolio_environment import PortfolioEnv 
+from deep_portfolio import DeepPortfolioAI # Seu modelo (usado como policy)
+# from config import ... # Outras configs
+
+RISK_FREE_RATE_ANNUAL = 0.2
+REWARD_WINDOW = 252
+frisk_free_per_step = 0.0 
+
+# Janela de recompensa para Sharpe (ex: últimos 60 passos/horas)
+# Deve ser menor ou igual ao ep_len_mean ou um valor razoável
+reward_calc_window = 60
+
+# 1. Carregar e preparar dados multi-ativos
+# (MULTI_ASSET_SYMBOLS viria do config.py)
+asset_keys_list = list(MULTI_ASSET_SYMBOLS.keys()) # ['crypto_eth', 'crypto_ada', ...]
+
+multi_asset_df = get_multi_asset_data_for_rl(
+    MULTI_ASSET_SYMBOLS, 
+    timeframe_yf='1h', # Ou TIMEFRAME_YFINANCE do config
+    days_to_fetch=365*2,
+    logger_instance=any
+    # Ou DAYS_TO_FETCH do config
+)
+
+print("Imprimindo retorno para df_combined passado para train_rl_portifolio")
+print(multi_asset_df)
+
+
+#-------------------
+
+if multi_asset_df is None or multi_asset_df.empty:
+    print("Falha ao carregar dados multi-ativos. Encerrando treinamento RL.")
+    exit()
+
+env = PortfolioEnv(df_multi_asset_features=multi_asset_df, asset_symbols_list=asset_keys_list) 
+print("Ambiente de Portfólio Criado.")
+
+# --- Usar a Política Customizada ---
+# Hiperparâmetros para o PPO
+learning_rate_ppo = PPO_LEARNING_RATE # Ex: 3e-4 ou 1e-4 (do config.py)
+n_steps_ppo = 2048 
+batch_size_ppo = 64
+ent_coef_ppo = 0.01 
+
+# policy_kwargs para passar para o __init__ da CustomPortfolioPolicySB3, se necessário
+# (além dos que já são passados para o features_extractor_kwargs)
+# Exemplo: Se você adicionou mais args ao __init__ de CustomPortfolioPolicySB3
+# policy_custom_kwargs = dict(
+#    meu_parametro_customizado=valor,
+#    # features_extractor_kwargs já é tratado pela classe base se você passar features_extractor_class
+# )
+
+print("Instanciando PPO com Política Customizada (DeepPortfolioAgentNetwork)...")
+model_ppo = PPO(
+    CustomPortfolioPolicySB3, 
+    env, 
+    verbose=1, 
+    learning_rate=learning_rate_ppo, # Pode ser uma função lr_schedule
+    n_steps=n_steps_ppo,
+    batch_size=batch_size_ppo,
+    ent_coef=ent_coef_ppo,
+    # policy_kwargs=policy_custom_kwargs, # Se tiver kwargs específicos para a política
+    tensorboard_log="./ppo_deep_portfolio_tensorboard/"
+)
+
+print("Iniciando treinamento do agente PPO com rede customizada...")
+model_ppo.learn(total_timesteps=1000000, progress_bar=True) # Comece com menos timesteps para teste (ex: 50k)
+
+model_ppo.save("rl_models/ppo_custom_deep_portfolio_agent")
+print("Modelo RL com política customizada treinado e salvo.")
+
+#----------
+
+
+
+
+# if multi_asset_df is None or multi_asset_df.empty:
+#     print("Falha ao carregar dados multi-ativos. Encerrando treinamento RL.")
+#     exit()
+
+# # 2. Criar o Ambiente
+# # O multi_asset_df já deve ter as features para observação E as colunas de preço de close original
+# env = PortfolioEnv(df_multi_asset_features=multi_asset_df, asset_symbols_list=asset_keys_list)
+
+
+# risk_free_per_step = 0.0 
+
+# # Janela de recompensa para Sharpe (ex: últimos 60 passos/horas)
+# # Deve ser menor ou igual ao ep_len_mean ou um valor razoável
+# reward_calc_window = 60
+
+# env = PortfolioEnv(
+#     df_multi_asset_features=multi_asset_df, 
+#     asset_symbols_list=asset_keys_list,
+#     initial_balance=100000, # Do config
+#     window_size=60, # Do config
+#     transaction_cost_pct=0.001, # Do config ou defina aqui
+#     reward_window_size=reward_calc_window,
+#     risk_free_rate_per_step=risk_free_per_step
+# )
+
+# # Opcional: Verificar se o ambiente está em conformidade com a API do Gymnasium
+# # check_env(env) # Pode dar avisos/erros se algo estiver errado
+# print("Ambiente de Portfólio Criado.")
+# print(f"Observation Space: {env.observation_space.shape}")
+# print(f"Action Space: {env.action_space.shape}")
+
+
+
+
+# # 3. Definir a Política de Rede Neural
+# # Stable-Baselines3 permite que você defina uma arquitetura customizada.
+# # Precisamos de uma forma de passar sua arquitetura DeepPortfolioAI para o PPO.
+# # Uma maneira é criar uma classe de política customizada.
+# # Por agora, vamos usar a política padrão "MlpPolicy" e depois vemos como integrar a sua.
+# # Ou, se DeepPortfolioAI for uma tf.keras.Model, podemos tentar usá-la em policy_kwargs.
+
+# # Para usar sua DeepPortfolioAI, você precisaria de uma FeatureExtractor customizada
+# # ou uma política que a incorpore, o que é mais avançado com Stable-Baselines3.
+# # Vamos começar com MlpPolicy para testar o ambiente.
+
+# # policy_kwargs = dict(
+# #     features_extractor_class=YourCustomFeatureExtractor, # Se a entrada precisar de tratamento especial
+# #     features_extractor_kwargs=dict(features_dim=128),
+# #     net_arch=[dict(pi=[256, 128], vf=[256, 128])] # Exemplo de arquitetura para policy e value networks
+# # )
+# # Ou, se o DeepPortfolioAI puder ser adaptado para ser a policy_network:
+# policy_kwargs = dict(
+#    net_arch=dict(
+#        pi=[{'model': DeepPortfolioAI(num_assets=env.num_assets)}], # Não é direto assim
+#        vf=[] # Value function pode ser separada ou compartilhada
+#    )
+# )
+
+# # Para começar e testar o ambiente, use a MlpPolicy padrão.
+# # O input da MlpPolicy será a observação achatada (WINDOW_SIZE * num_total_features).
+# # Isso pode não ser ideal para dados sequenciais. "MlpLstmPolicy" é melhor.
+
+# model_ppo = PPO("MlpPolicy", env, verbose=1, ent_coef=0.01, tensorboard_log="./ppo_portfolio_tensorboard/")
+# # Se "MlpLstmPolicy" não funcionar bem com o shape da observação (janela, features_totais),
+# # você pode precisar de um FeatureExtractor que achate a janela, ou uma política customizada.
+
+# # 4. Treinar o Agente
+# print("Iniciando treinamento do agente PPO...")
+# model_ppo.learn(total_timesteps=int("1000000"), progress_bar=True) # Aumente timesteps para treino real
+
+# # 5. Salvar o Modelo Treinado
+# model_ppo.save("rl_models/ppo_deep_portfolio_agent")
+# print("Modelo RL treinado salvo.")
+
+
+# # (Opcional) Testar o agente treinado
+# obs, _ = env.reset()
+# for _ in range(200):
+#     action, _states = model_ppo.predict(obs, deterministic=True)
+#     obs, rewards, terminated, truncated, info = env.step(action)
+#     env.render()
+#     if terminated or truncated:
+#         obs, _ = env.reset()
+# env.close()

api/main.py

@@ -0,0 +1,61 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from endpoints.predict import router as predict_router
+from agents.dataset_update_agent import router as dataset_router
+from agents.financial_data_agent import router as finance_router
+from agents.investment_agent import router as invest_router
+from agents.rl_agent import router as rl_router
+from utils.logger import get_logger
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from jinja2 import Environment, FileSystemLoader
+import os
+
+
+
+
+logger = get_logger()
+
+app = FastAPI(title="ATCoin Neural Agents")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Registrar rotas
+app.include_router(predict_router)
+app.include_router(dataset_router, prefix="/dataset")
+app.include_router(finance_router, prefix="/finance")
+app.include_router(invest_router, prefix="/invest")
+app.include_router(rl_router, prefix="/rl")
+
+
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index():
+    agentes = [
+        {
+            "nome": "Captura de Dados",
+            "status": "Ativo",
+            "ultima_acao": "08/05/2025 10:00",
+            "proxima_execucao": "09/05/2025 10:00",
+            "resultado": "12 ativos atualizados"
+        },
+        {
+            "nome": "PPO Trainer",
+            "status": "Treinando",
+            "ultima_acao": "08/05/2025 12:00",
+            "proxima_execucao": "09/05/2025 12:00",
+            "resultado": "Reward: 0.89"
+        },
+        # outros agentes...
+    ]
+
+    template = templates.get_template("index.html")
+    return HTMLResponse(template.render(agentes=agentes))

app-modularizado.py

@@ -0,0 +1,606 @@
+# 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
+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.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 (Só executa se a coleta de dados não falhou criticamente)
+    # =========================================================================
+    investment_decisions: List[Dict[str, Any]] = [] 
+    total_usd_allocated_by_rnn = 0.0
+
+    if final_status == "completed": # Prossiga apenas se não houve erro crítico anterior
+        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
+        try:
+            # Placeholder para a LÓGICA REAL DA RNN (RNN_LOGIC_PLACEHOLDER)
+            # Esta seção precisa ser preenchida com:
+            # 1. Carregamento do seu modelo RNN treinado (ex: TensorFlow, PyTorch, scikit-learn).
+            #    O modelo pode ser carregado uma vez quando a API inicia, ou sob demanda.
+            #    Se for grande, carregue na inicialização da API.
+            #    Ex: from rnn.models.my_rnn_predictor import MyRNNModel
+            #        if 'rnn_model_instance' not in app.state: # Carregar uma vez
+            #            app.state.rnn_model_instance = MyRNNModel(path_to_model_weights)
+            #        predictor = app.state.rnn_model_instance
+            #
+            # 2. Pré-processamento dos `market_data_results` para o formato que sua RNN espera.
+            #    Ex: features = preprocess_market_data_for_rnn(market_data_results)
+            #
+            # 3. Inferência/Predição com a RNN.
+            #    Ex: raw_rnn_output = await predictor.predict_async(features, client_profile_if_any)
+            #
+            # 4. Pós-processamento do output da RNN para gerar `investment_decisions` no formato:
+            #    [{ "asset_id": "BTC/USDT", "type": "CRYPTO", "action": "BUY", 
+            #       "target_usd_amount": 5000.00, "confidence_score": 0.85, 
+            #       "stop_loss_price": 60000, "take_profit_price": 75000, 
+            #       "reasoning": "RNN output details..." }, ...]
+            
+            # Simulação atual:
+            await asyncio.sleep(random.uniform(5, 10)) # Simula processamento da RNN
+            if market_data_results.get("crypto"):
+                if random.random() > 0.2: # 80% chance
+                    num_crypto_to_invest = min(random.randint(1, 2), len(market_data_results["crypto"]))
+                    available_crypto_keys = [k for k,v in market_data_results["crypto"].items() if not v.get("error")]
+                    if available_crypto_keys:
+                        chosen_pairs_keys = random.sample(available_crypto_keys, k=min(num_crypto_to_invest, len(available_crypto_keys)))
+                        
+                        base_allocation_per_asset = amount / len(chosen_pairs_keys) if chosen_pairs_keys else 0
+
+                        for crypto_key in chosen_pairs_keys:
+                            asset_symbol = crypto_key.replace("_", "/")
+                            # Alocação mais realista: não necessariamente usar todo o 'amount'
+                            # E a RNN pode dar pesos diferentes
+                            asset_specific_allocation_factor = random.uniform(0.3, 0.7) / len(chosen_pairs_keys)
+                            allocated_amount = amount * asset_specific_allocation_factor
+                            
+                            # Evitar alocar mais do que o 'amount' total disponível
+                            if total_usd_allocated_by_rnn + allocated_amount > amount * 0.95: # Deixa uma margem
+                                allocated_amount = max(0, (amount * 0.95) - total_usd_allocated_by_rnn)
+                            
+                            if allocated_amount > 10: # Investimento mínimo de $10 (exemplo)
+                                investment_decisions.append({
+                                    "asset_id": asset_symbol, "type": "CRYPTO", "action": "BUY",
+                                    "target_usd_amount": round(allocated_amount, 2),
+                                    "reasoning": f"Simulated RNN signal for {asset_symbol}"
+                                })
+                                total_usd_allocated_by_rnn += round(allocated_amount, 2)
+            
+            if not investment_decisions:
+                logger.info(f"BG TASK [{rnn_tx_id}]: RNN não gerou decisões de COMPRA.")
+            else:
+                logger.info(f"BG TASK [{rnn_tx_id}]: RNN gerou {len(investment_decisions)} decisões de compra: {investment_decisions}")
+
+        except Exception as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro durante análise RNN: {str(e)}", exc_info=True)
+            rnn_analysis_success = False
+            error_details += f"RNN analysis failed: {str(e)}; "
+        
+        if not rnn_analysis_success:
+            final_status = "failed_rnn_analysis"
+        
+        transactions_db[rnn_tx_id]["rnn_decisions"] = investment_decisions
+    
+    # Atualiza o total_usd_allocated_by_rnn com base nas decisões finais
+    total_usd_allocated_by_rnn = sum(d['target_usd_amount'] for d in investment_decisions if d['action'] == 'BUY')
+    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 s
+# 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)

app-old-no-module.py

@@ -0,0 +1,901 @@
+
+
+import os
+import uuid
+import time
+import hmac
+import hashlib
+import json
+from datetime import datetime, timedelta
+from typing import Dict, Any
+import ccxt.async_support as ccxt 
+
+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 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.")
+
+
+
+#CHAVES PARA CCXT (para Binance)
+# configuradas como vriaveis no Hugging Face Space
+
+CCXT_EXCHANGE_ID = os.environ.get("CCXT_EXCHANGE_ID", "binance") 
+CCXT_API_KEY = os.environ.get("CCXT_API_KEY")
+CCXT_API_SECRET = os.environ.get("CCXT_API_SECRET")
+CCXT_API_PASSWORD = os.environ.get("CCXT_API_PASSWORD") # Opcional
+
+# Binance Testnet
+CCXT_SANDBOX_MODE = os.environ.get("CCXT_SANDBOX_MODE", "false").lower() == "true"
+
+
+
+
+
+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
+):
+    """
+    Esta função roda em background. Simula a coleta de dados, RNN, execução e tokenização.
+    No final, chama o callback para o aibank.
+    """
+    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" # Status geral inicial
+    transactions_db[rnn_tx_id]["status_details"] = "Initializing investment cycle"
+    
+    final_status = "completed" # Status final presumido
+    error_details = ""
+    calculated_final_amount = amount # Valor inicial, será modificado
+
+    # Inicializa o objeto da exchange ccxt
+    exchange = None
+    if CCXT_API_KEY and CCXT_API_SECRET: #nicializa se as chaves básicas estiverem presentes
+        try:
+            exchange_class = getattr(ccxt, CCXT_EXCHANGE_ID)
+            config = {
+                'apiKey': CCXT_API_KEY,
+                'secret': CCXT_API_SECRET,
+                'enableRateLimit': True, #  evitar bans da API
+                # 'verbose': True, # Para debug detalhado das chamadas ccxt
+            }
+            if CCXT_API_PASSWORD:
+                config['password'] = CCXT_API_PASSWORD
+            
+            exchange = exchange_class(config)
+
+            if CCXT_SANDBOX_MODE:
+                if hasattr(exchange, 'set_sandbox_mode'): # Nem todas as exchanges suportam isso diretamente em ccxt
+                    exchange.set_sandbox_mode(True)
+                    logger.info(f"BG TASK [{rnn_tx_id}]: CCXT configurado para modo SANDBOX para {CCXT_EXCHANGE_ID}.")
+                elif 'test' in exchange.urls: # usar testnet another.way
+                    exchange.urls['api'] = exchange.urls['test']
+                    logger.info(f"BG TASK [{rnn_tx_id}]: CCXT URLs alteradas para TESTNET para {CCXT_EXCHANGE_ID}.")
+                else:
+                    logger.warning(f"BG TASK [{rnn_tx_id}]: Modo SANDBOX solicitado mas não explicitamente suportado por ccxt para {CCXT_EXCHANGE_ID} ou URL de teste não encontrada.")
+            
+            # Carregar mercados para validar símbolos, demorado.
+            # await exchange.load_markets() 
+            # logger.info(f"BG TASK [{rnn_tx_id}]: Mercados carregados para {CCXT_EXCHANGE_ID}.")
+
+        except AttributeError:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Exchange ID '{CCXT_EXCHANGE_ID}' inválida ou não suportada pelo ccxt.")
+            error_details += f"Invalid CCXT_EXCHANGE_ID: {CCXT_EXCHANGE_ID}; "
+            final_status = "failed_config" # Um novo status para falha de configuração
+            # (Pular para o callback aqui)
+        except Exception as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro ao inicializar ccxt para {CCXT_EXCHANGE_ID}: {str(e)}", exc_info=True)
+            error_details += f"CCXT initialization error: {str(e)}; "
+            final_status = "failed_config"
+            # (Pular para o callback aqui)
+    else:
+        logger.warning(f"BG TASK [{rnn_tx_id}]: CCXT_API_KEY ou CCXT_API_SECRET não configurados. A coleta de dados de cripto e execução de ordens via ccxt serão puladas.")
+        #Decidir se é uma falha fatal ou se a estratégia pode prosseguir sem dados de cripto.
+        # Precisa lidar com dados ausentes.
+
+
+    # =========================================================================
+    # 1. COLETAR DADOS DE MERCADO (com ccxt integrado)
+    # =========================================================================
+    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": {}, # Dados específicos de cripto
+        "stocks": {}, # Dados de ações (integrar yfinance ou outro)
+        "other": {}   # Outros dados
+    }
+    market_data_fetch_success = True
+
+    # --- Defina os pares de cripto ---
+    # Estes poderiam vir de uma configuração, ou serem dinâmicos.
+    crypto_pairs_to_fetch = ["BTC/USDT", "ETH/USDT", "SOL/USDT"] 
+
+    if exchange: # Buscar se a exchange foi inicializada corretamente
+        try:
+            for pair in crypto_pairs_to_fetch:
+                pair_data = {}
+                if exchange.has['fetchTicker']:
+                    ticker = await exchange.fetch_ticker(pair)
+                    pair_data['ticker'] = {
+                        'last': ticker.get('last'),
+                        'bid': ticker.get('bid'),
+                        'ask': ticker.get('ask'),
+                        'volume': ticker.get('baseVolume'), # Ou 'quoteVolume'
+                        'timestamp': ticker.get('timestamp')
+                    }
+                    logger.info(f"BG TASK [{rnn_tx_id}]: Ticker {pair}: Preço {ticker.get('last')}")
+                
+                if exchange.has['fetchOHLCV']:
+                    # timeframe: '1m', '5m', '15m', '1h', '4h', '1d', '1w', '1M'
+                    # limit: número de candles
+                    ohlcv = await exchange.fetch_ohlcv(pair, timeframe='1h', limit=72) # Últimas 72 horas
+                    # Formato OHLCV: [timestamp, open, high, low, close, volume]
+                    pair_data['ohlcv_1h'] = ohlcv
+                    logger.info(f"BG TASK [{rnn_tx_id}]: Coletado {len(ohlcv)} candles OHLCV para {pair} (1h).")
+
+                # Outros dados que ccxt:
+                # if exchange.has['fetchOrderBook']:
+                #     order_book = await exchange.fetch_order_book(pair, limit=5) # Top 5 bids/asks
+                #     pair_data['order_book_L1'] = { # Exemplo de Level 1
+                #         'bids': order_book['bids'][0] if order_book['bids'] else None,
+                #         'asks': order_book['asks'][0] if order_book['asks'] else None,
+                #     }
+                # if exchange.has['fetchTrades']: # Últimas negociações públicas
+                #     trades = await exchange.fetch_trades(pair, limit=10)
+                #     pair_data['recent_trades'] = trades
+
+                market_data_results["crypto"][pair.replace("/", "_")] = pair_data # Usar _ para chaves de dict seguras
+
+            logger.info(f"BG TASK [{rnn_tx_id}]: Dados de cripto via ccxt coletados.")
+
+        except ccxt.NetworkError as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro de rede ccxt ao coletar dados de mercado: {str(e)}", exc_info=True)
+            market_data_fetch_success = False
+            error_details += f"CCXT NetworkError: {str(e)}; "
+        except ccxt.ExchangeError as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro da exchange ccxt ao coletar dados de mercado: {str(e)}", exc_info=True)
+            market_data_fetch_success = False
+            error_details += f"CCXT ExchangeError: {str(e)}; "
+        except Exception as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro geral ao coletar dados de cripto via ccxt: {str(e)}", exc_info=True)
+            market_data_fetch_success = False
+            error_details += f"General CCXT data collection error: {str(e)}; "
+    else:
+        logger.info(f"BG TASK [{rnn_tx_id}]: Instância da exchange ccxt não disponível. Pulando coleta de dados de cripto.")
+        # Se não há 'exchange', a coleta de dados de cripto não pode ocorrerá.
+        # Erro, dependendo se as chaves Not.ok.
+        if CCXT_API_KEY and CCXT_API_SECRET: # Chaves dadas mas a 'exchange' falhou na init
+             market_data_fetch_success = False # Falha se a config estava lá
+             error_details += "CCXT exchange object not initialized despite API keys being present; "
+
+
+    # --- Coleta de dados para outros tipos de ativos (Ações com yfinance) ---
+    # try:
+    #     import yfinance as yf
+    #     aapl = yf.Ticker("AAPL")
+    #     hist_aapl = aapl.history(period="5d", interval="1h") # Últimos 5 dias, candles de 1h
+    #     if not hist_aapl.empty:
+    #         market_data_results["stocks"]["AAPL"] = {
+    #             "ohlcv_1h": [[ts.timestamp() * 1000] + list(row) for ts, row in hist_aapl[['Open', 'High', 'Low', 'Close', 'Volume']].iterrows()]
+    #         }
+    #         logger.info(f"BG TASK [{rnn_tx_id}]: Coletado {len(hist_aapl)} candles para AAPL via yfinance.")
+    # except Exception as e:
+    #     logger.warning(f"BG TASK [{rnn_tx_id}]: Falha ao buscar dados de ações com yfinance: {e}")
+    #   
+    
+
+    # --- Simulação para outros dados, se necessário ---
+    market_data_results["other"]['simulated_index_level'] = random.uniform(10000, 15000)
+    market_data_results["other"]['simulated_crypto_sentiment'] = random.uniform(-1, 1)
+    
+    if not market_data_fetch_success and (CCXT_API_KEY and CCXT_API_SECRET): # Se as chaves de cripto foram dadas e a coleta falhou
+        final_status = "failed_market_data"
+        logger.error(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado falhou criticamente. {error_details}")
+        # (Pular para o callback aqui, pois a RNN pode não ter dados suficientes)
+        # 'return' ou lógica de pular precisa ser implementada se a falha for fatal
+        # Registrar e permitir que a lógica da RNN tente lidar com dados ausentes/parciais
+        pass 
+    
+    transactions_db[rnn_tx_id]["market_data_collected"] = market_data_results # Armazena para auditoria/debug
+    transactions_db[rnn_tx_id]["status_details"] = "Processing RNN analysis"
+    logger.info(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado concluída (sucesso: {market_data_fetch_success}).")
+
+    # =========================================================================
+    # 2. ANÁLISE PELA RNN E TOMADA DE DECISÃO 
+    # =========================================================================
+    # (alimentada por market_data_results)
+    # ...
+    logger.info(f"BG TASK [{rnn_tx_id}]: Executando análise RNN com os dados coletados...")
+    transactions_db[rnn_tx_id]["status_details"] = "Running RNN model"
+    investment_decisions = [] 
+    rnn_analysis_success = True
+
+    try:
+        
+        # A RNN precisará ser capaz de lidar com a estrutura de market_data_results,
+        # incluindo a possibilidade de alguns dados estarem ausentes se a coleta falhar.
+       
+        # investment_decisions = await rnn_model.predict_async(market_data_results, amount_to_invest=amount)
+        
+        # Simulação para prosseguir:
+        await asyncio.sleep(random.uniform(8, 15)) 
+        if market_data_results["crypto"]: # Com dados de cripto
+            if random.random() > 0.1: 
+                num_crypto_assets_to_invest = random.randint(1, len(crypto_pairs_to_fetch))
+                chosen_pairs = random.sample(list(market_data_results["crypto"].keys()), k=num_crypto_assets_to_invest)
+                
+                for crypto_key in chosen_pairs: # crypto_key  "BTC_USDT"
+                    asset_symbol = crypto_key.replace("_", "/") # Converte de volta para "BTC/USDT"
+                    allocated_amount = (amount / num_crypto_assets_to_invest) * random.uniform(0.7, 0.9) # Aloca uma parte do total
+                    investment_decisions.append({
+                        "asset_id": asset_symbol, # Usa o símbolo da exchange
+                        "type": "CRYPTO",
+                        "action": "BUY",
+                        "target_usd_amount": round(allocated_amount, 2),
+                        "reasoning": f"RNN signal for {asset_symbol} based on simulated data and ticker {market_data_results['crypto'][crypto_key].get('ticker', {}).get('last', 'N/A')}"
+                    })
+        else:
+            logger.info(f"BG TASK [{rnn_tx_id}]: Sem dados de cripto para a RNN processar.")
+
+        if not investment_decisions:
+            logger.info(f"BG TASK [{rnn_tx_id}]: RNN não gerou nenhuma decisão de investimento.")
+        else:
+            logger.info(f"BG TASK [{rnn_tx_id}]: RNN gerou {len(investment_decisions)} decisões: {investment_decisions}")
+
+    except Exception as e:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro durante análise RNN: {str(e)}", exc_info=True)
+        rnn_analysis_success = False
+        error_details += f"RNN analysis failed: {str(e)}; "
+    
+    if not rnn_analysis_success:
+        final_status = "failed_rnn_analysis"
+        # (Pular para o callback)
+        pass
+
+    transactions_db[rnn_tx_id]["rnn_decisions"] = investment_decisions
+    transactions_db[rnn_tx_id]["status_details"] = "Preparing to execute orders"
+    total_usd_allocated_by_rnn = sum(d['target_usd_amount'] for d in investment_decisions if d['action'] == 'BUY')
+
+
+    # =========================================================================
+    # 3. EXECUÇÃO DE ORDENS (Será detalhado no próximo passo)
+    # =========================================================================
+    # ... (execução de ordens aqui, usando `exchange` ccxt e `investment_decisions`)
+    # ... (Incluindo cálculo de `current_portfolio_value` e `cash_remaining_after_allocation`)
+    logger.info(f"BG TASK [{rnn_tx_id}]: Executando ordens baseadas nas decisões da RNN...")
+    transactions_db[rnn_tx_id]["status_details"] = "Executing investment orders"
+    executed_trades_info = []
+    order_execution_success = True
+    cash_remaining_after_allocation = amount - total_usd_allocated_by_rnn
+    current_portfolio_value = 0 # Valor dos ativos comprados
+
+    # Placeholder para execução
+    if investment_decisions:
+        for decision in investment_decisions:
+            if decision.get("action") == "BUY":
+                usd_amount_to_spend = decision.get("target_usd_amount")
+                simulated_cost = usd_amount_to_spend * random.uniform(0.99, 1.0)
+                executed_trades_info.append({
+                    "asset": decision.get("asset_id"), "order_id": f"sim_ord_{uuid.uuid4()}", 
+                    "status": "filled", "cost_usd": simulated_cost
+                })
+                current_portfolio_value += simulated_cost
+        await asyncio.sleep(random.uniform(1,3) * len(investment_decisions)) # Simula tempo de execução
+    else:
+        cash_remaining_after_allocation = amount
+
+    transactions_db[rnn_tx_id]["executed_trades"] = executed_trades_info
+    transactions_db[rnn_tx_id]["status_details"] = "Simulating holding period and profit/loss"
+
+
+    # =========================================================================
+    # 4. SIMULAÇÃO DO PERÍODO DE INVESTIMENTO E CÁLCULO DE LUCRO/PERDA
+    # =========================================================================
+    # ... (Inserir lógia )
+    logger.info(f"BG TASK [{rnn_tx_id}]: Simulando período de investimento e fechamento de posições...")
+    await asyncio.sleep(random.uniform(5, 10)) 
+
+    if current_portfolio_value > 0:
+        profit_on_invested_part = current_portfolio_value * (0.042 * random.uniform(0.8, 1.2)) 
+        value_of_investments_at_eod = current_portfolio_value + profit_on_invested_part
+    else: 
+        value_of_investments_at_eod = 0
+        profit_on_invested_part = 0
+    
+    calculated_final_amount = value_of_investments_at_eod + cash_remaining_after_allocation
+    
+    logger.info(f"BG TASK [{rnn_tx_id}]: Valor inicial total: {amount:.2f}. "
+                f"Valor alocado para investimento: {total_usd_allocated_by_rnn:.2f}. "
+                f"Valor dos investimentos no EOD: {value_of_investments_at_eod:.2f}. "
+                f"Caixa não alocado: {cash_remaining_after_allocation:.2f}. "
+                f"Valor final total: {calculated_final_amount:.2f}")
+
+    transactions_db[rnn_tx_id]["eod_portfolio_value_simulated"] = value_of_investments_at_eod
+
+    # =========================================================================
+    # 5. TOKENIZAÇÃO / REGISTRO DA OPERAÇÃO
+    # =========================================================================
+    # ... (Inserir)
+    logger.info(f"BG TASK [{rnn_tx_id}]: Registrando (tokenizando) operação detalhadamente...")
+    # ... (código do hash proof)
+    await asyncio.sleep(1)
+
+    # =========================================================================
+    # 6. PREPARAR E ENVIAR CALLBACK PARA AIBANK
+    # =========================================================================
+    # (Fechamento da conexão ccxt antes do callback, se a conexão foi aberta e bem sucedida)
+    if exchange and hasattr(exchange, 'close'):
+        try:
+            await exchange.close()
+            logger.info(f"BG TASK [{rnn_tx_id}]: Conexão ccxt com {CCXT_EXCHANGE_ID} fechada.")
+        except Exception as e:
+            logger.warning(f"BG TASK [{rnn_tx_id}]: Erro ao fechar conexão ccxt: {str(e)}")
+
+    # (callback , usando `final_status`, `error_details`, `calculated_final_amount`)
+    # ...
+    if not AIBANK_CALLBACK_URL or not CALLBACK_SHARED_SECRET:
+        logger.error(f"BG TASK [{rnn_tx_id}]: AIBANK_CALLBACK_URL ou CALLBACK_SHARED_SECRET não configurado. Não é possível enviar callback.")
+        transactions_db[rnn_tx_id]["callback_status"] = "config_missing"
+        return # Não pode prosseguir sem config de callback
+
+    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=calculated_final_amount,
+        profit_loss=calculated_final_amount - amount,
+        status=final_status, # O status final da operação
+        timestamp=datetime.utcnow(),
+        details=error_details if final_status != "completed" else "Investment cycle completed successfully."
+    )
+    payload_json = callback_payload_data.model_dump_json()
+    signature = hmac.new(CALLBACK_SHARED_SECRET.encode('utf-8'), payload_json.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}'")
+    transactions_db[rnn_tx_id]["callback_status"] = "sending"
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(AIBANK_CALLBACK_URL, content=payload_json, headers=headers, timeout=30.0)
+            response.raise_for_status()
+            logger.info(f"BG TASK [{rnn_tx_id}]: Callback enviado com sucesso para AIBank. Status da resposta: {response.status_code}")
+            transactions_db[rnn_tx_id]["callback_status"] = f"sent_success_{response.status_code}"
+    except Exception as e: # Captura mais genérica para erros de callback
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro ao enviar callback para AIBank: {str(e)}", exc_info=True)
+        # Classificar o erro para o log
+        if isinstance(e, httpx.RequestError):
+            transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_request_error"
+        elif isinstance(e, httpx.HTTPStatusError):
+            transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_http_error_{e.response.status_code}"
+        else:
+            transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_unknown_error"
+
+
+
+# --- 
+""" 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_market_data"
+    
+    final_status = "completed"
+    error_details = ""
+    calculated_final_amount = amount # Valor inicial
+
+    try:
+        # 1. COLETAR DADOS DE MERCADO (Placeholder)
+                
+        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 = {}
+        market_data_fetch_success = True
+
+        # Exemplo para Cripto com ccxt (requer 'pip install ccxt')
+        # import ccxt.async_support as ccxt # Coloque no topo do app.py
+        # exchange_id = 'binance' # Exemplo
+        # exchange_class = getattr(ccxt, exchange_id)
+        # exchange = exchange_class({
+        #     'apiKey': EXCHANGE_API_KEY, # Do os.environ
+        #     'secret': EXCHANGE_API_SECRET, # Do os.environ
+        #     'enableRateLimit': True, # Importante
+        # })
+
+        try:
+            # --- Exemplo para buscar dados de BTC/USDT ---
+            # if exchange.has['fetchTicker']:
+            #     ticker_btc = await exchange.fetch_ticker('BTC/USDT')
+            #     market_data_results['BTC_USDT_ticker'] = ticker_btc
+            #     logger.info(f"BG TASK [{rnn_tx_id}]: Ticker BTC/USDT: {ticker_btc['last']}")
+            # if exchange.has['fetchOHLCV']:
+            #     ohlcv_btc = await exchange.fetch_ohlcv('BTC/USDT', timeframe='1h', limit=100) # Últimas 100 horas
+            #     market_data_results['BTC_USDT_ohlcv_1h'] = ohlcv_btc
+            #     logger.info(f"BG TASK [{rnn_tx_id}]: Coletado {len(ohlcv_btc)} candles OHLCV para BTC/USDT 1h.")
+            
+            # --- Exemplo para Ações com yfinance (requer 'pip install yfinance') ---
+            # import yfinance as yf # Coloque no topo do app.py
+            # aapl = yf.Ticker("AAPL")
+            # hist_aapl = aapl.history(period="1mo") # Dados do último mês
+            # market_data_results['AAPL_history_1mo'] = hist_aapl.to_dict() # Pode ser grande, serialize com cuidado
+            # current_price_aapl = hist_aapl['Close'].iloc[-1] if not hist_aapl.empty else None
+            # market_data_results['AAPL_current_price'] = current_price_aapl
+            # logger.info(f"BG TASK [{rnn_tx_id}]: Preço atual AAPL (yfinance): {current_price_aapl}")
+
+            # --- Placeholder para sua lógica real de coleta ---
+            # Você precisará definir QUAIS ativos e QUAIS dados são necessários para sua RNN.
+            # Este é um ponto crucial para sua estratégia.
+            # Simulação para prosseguir:
+            await asyncio.sleep(random.uniform(3, 7)) # Simula demora da coleta real
+            market_data_results['simulated_index_level'] = random.uniform(10000, 15000)
+            market_data_results['simulated_crypto_sentiment'] = random.uniform(-1, 1)
+            logger.info(f"BG TASK [{rnn_tx_id}]: Dados de mercado (simulados/reais) coletados.")
+
+        except Exception as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro ao coletar dados de mercado: {str(e)}", exc_info=True)
+            market_data_fetch_success = False
+            error_details += f"Market data collection failed: {str(e)}; "
+            # Decida se a falha aqui é crítica e impede de continuar.
+            # Se sim, atualize final_status e pule para o callback.
+
+        # finally: # Importante para fechar conexões de exchange em ccxt
+        #    if 'exchange' in locals() and hasattr(exchange, 'close'):
+        #        await exchange.close()
+
+        if not market_data_fetch_success:
+            # Lógica para lidar com falha na coleta de dados (ex: não prosseguir)
+            final_status = "failed_market_data"
+            # ... (atualize transactions_db e pule para a seção de callback) ...
+            # (Este 'return' ou lógica de pular precisa ser implementada se a falha for fatal)
+            pass # Por ora, deixamos prosseguir com dados possivelmente incompletos ou apenas simulados
+
+        transactions_db[rnn_tx_id]["market_data_collected"] = market_data_results # Armazene para auditoria/debug
+        transactions_db[rnn_tx_id]["status_details"] = "Processing RNN analysis"
+
+
+        # 2. ANÁLISE PELA RNN E TOMADA DE DECISÃO (Placeholder)
+        l
+
+        logger.info(f"BG TASK [{rnn_tx_id}]: Executando análise RNN com os dados coletados...")
+        transactions_db[rnn_tx_id]["status_details"] = "Running RNN model"
+        investment_decisions = [] # Lista de decisões: {'asset': 'BTC/USDT', 'action': 'BUY', 'amount_usd': 5000, 'price_target': 70000}
+        rnn_analysis_success = True
+
+        try:
+            # --- SUBSTITUA PELA CHAMADA AO SEU MODELO RNN ---
+            # Exemplo: Supondo que você tenha uma classe ou função rnn_predictor
+            # from rnn.models.predictor import rnn_predictor # Exemplo de import
+            
+            # Supondo que seu predictor precise dos dados de mercado e do montante a investir
+            # investment_decisions = await rnn_predictor.generate_signals_async(
+            #     market_data_results, 
+            #     amount_to_invest=amount # O montante total disponível para este ciclo
+            # )
+            
+            # Simulação para prosseguir:
+            await asyncio.sleep(random.uniform(8, 15)) # Simula processamento da RNN
+            if random.random() > 0.1: # 90% de chance de "decidir" investir
+                num_assets_to_invest = random.randint(1, 3)
+                for i in range(num_assets_to_invest):
+                    asset_name = random.choice(["SIMULATED_CRYPTO_X", "SIMULATED_STOCK_Y", "SIMULATED_BOND_Z"])
+                    action = random.choice(["BUY", "HOLD"]) # Simplificado, sem SELL por enquanto
+                    if action == "BUY":
+                        # Alocar uma porção do 'amount' total para este ativo
+                        allocated_amount = (amount / num_assets_to_invest) * random.uniform(0.8, 1.0) 
+                        investment_decisions.append({
+                            "asset_id": f"{asset_name}_{i}",
+                            "type": "CRYPTO" if "CRYPTO" in asset_name else "STOCK", # Exemplo
+                            "action": action,
+                            "target_usd_amount": round(allocated_amount, 2),
+                            "reasoning": "RNN signal strong based on simulated data" # Adicione o output real da RNN
+                        })
+            
+            if not investment_decisions:
+                logger.info(f"BG TASK [{rnn_tx_id}]: RNN não gerou nenhuma decisão de investimento (ou decidiu não investir).")
+                # Isso pode ser um resultado válido.
+            else:
+                logger.info(f"BG TASK [{rnn_tx_id}]: RNN gerou {len(investment_decisions)} decisões: {investment_decisions}")
+
+        except Exception as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro durante análise RNN: {str(e)}", exc_info=True)
+            rnn_analysis_success = False
+            error_details += f"RNN analysis failed: {str(e)}; "
+
+        if not rnn_analysis_success:
+            final_status = "failed_rnn_analysis"
+            # ... (atualize transactions_db e pule para a seção de callback) ...
+            pass
+
+        transactions_db[rnn_tx_id]["rnn_decisions"] = investment_decisions
+        transactions_db[rnn_tx_id]["status_details"] = "Preparing to execute orders"
+
+        # Antes de executar ordens, vamos calcular o valor que REALMENTE foi investido
+        # e o que pode ter sobrado, já que a RNN pode não usar todo o 'amount'.
+        total_usd_allocated_by_rnn = sum(d['target_usd_amount'] for d in investment_decisions if d['action'] == 'BUY')
+        # calculated_final_amount = amount # Inicializa com o montante original
+        # Esta variável será atualizada após a execução das ordens e cálculo do lucro/perda
+
+    
+        # 3. EXECUÇÃO DE ORDENS (Placeholder)
+              
+        # Dentro de execute_investment_strategy_background, substituindo a seção de execução de ordens:
+
+        logger.info(f"BG TASK [{rnn_tx_id}]: Executando ordens baseadas nas decisões da RNN...")
+        transactions_db[rnn_tx_id]["status_details"] = "Executing investment orders"
+        executed_trades_info = []
+        order_execution_success = True
+
+        # O calculated_final_amount começa como o 'amount' inicial.
+        # Vamos deduzir o que foi efetivamente usado para compras
+        # e depois adicionar os lucros/perdas.
+        # Por enquanto, vamos assumir que o investimento visa usar o 'total_usd_allocated_by_rnn'.
+        # E o restante do 'amount' não alocado fica como "cash".
+        cash_remaining_after_allocation = amount - total_usd_allocated_by_rnn
+        current_portfolio_value = 0 # Valor dos ativos comprados
+
+        # --- Exemplo de lógica de execução para decisões de COMPRA (BUY) ---
+        if investment_decisions: # Apenas se houver decisões
+            # exchange_exec = ccxt.binance({'apiKey': EXCHANGE_API_KEY, 'secret': EXCHANGE_API_SECRET}) # Exemplo
+            try:
+                for decision in investment_decisions:
+                    if decision.get("action") == "BUY":
+                        asset_id_to_buy = decision.get("asset_id") # Ex: "BTC/USDT" ou um ID interno que mapeia para um símbolo
+                        usd_amount_to_spend = decision.get("target_usd_amount")
+                        
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Tentando comprar {usd_amount_to_spend} USD de {asset_id_to_buy}")
+                        
+                        # --- SUBSTITUA PELA LÓGICA REAL DE EXECUÇÃO NA EXCHANGE ---
+                        # Exemplo com ccxt (precisa de mais detalhes como símbolo de mercado correto):
+                        # symbol_on_exchange = convert_asset_id_to_exchange_symbol(asset_id_to_buy, exchange_exec.id)
+                        # current_price = (await exchange_exec.fetch_ticker(symbol_on_exchange))['last']
+                        # amount_of_asset_to_buy = usd_amount_to_spend / current_price
+                        
+                        # order = await exchange_exec.create_market_buy_order(symbol_on_exchange, amount_of_asset_to_buy)
+                        # logger.info(f"BG TASK [{rnn_tx_id}]: Ordem de compra para {asset_id_to_buy} enviada: {order['id']}")
+                        # executed_trades_info.append({
+                        #     "asset": asset_id_to_buy,
+                        #     "order_id": order['id'],
+                        #     "status": order.get('status', 'unknown'),
+                        #     "amount_filled": order.get('filled', 0),
+                        #     "avg_price": order.get('average', current_price),
+                        #     "cost_usd": order.get('cost', usd_amount_to_spend), # Custo real da ordem
+                        #     "fees": order.get('fee', {}),
+                        # })
+                        # current_portfolio_value += order.get('cost', usd_amount_to_spend) # Adiciona o valor do ativo comprado
+                        
+                        # Simulação para prosseguir:
+                        await asyncio.sleep(random.uniform(1, 3)) # Simula envio de ordem
+                        simulated_order_id = f"sim_ord_{uuid.uuid4()}"
+                        simulated_cost = usd_amount_to_spend * random.uniform(0.99, 1.0) # Slippage simulado
+                        executed_trades_info.append({
+                            "asset": asset_id_to_buy,
+                            "order_id": simulated_order_id,
+                            "status": "filled",
+                            "amount_filled": simulated_cost / random.uniform(100, 200), # Qtd de ativo simulada
+                            "avg_price": random.uniform(100, 200), # Preço simulado
+                            "cost_usd": simulated_cost,
+                            "fees": {"currency": "USD", "cost": simulated_cost * 0.001} # Taxa simulada
+                        })
+                        current_portfolio_value += simulated_cost
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Ordem simulada {simulated_order_id} para {asset_id_to_buy} preenchida, custo {simulated_cost:.2f} USD.")
+                    else:
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Decisão '{decision.get('action')}' para {decision.get('asset_id')} não é uma compra, pulando execução por enquanto.")
+            
+            except Exception as e:
+                logger.error(f"BG TASK [{rnn_tx_id}]: Erro durante execução de ordens: {str(e)}", exc_info=True)
+                order_execution_success = False
+                error_details += f"Order execution failed: {str(e)}; "
+            # finally:
+            #     if 'exchange_exec' in locals() and hasattr(exchange_exec, 'close'):
+            #         await exchange_exec.close()
+        else:
+            logger.info(f"BG TASK [{rnn_tx_id}]: Nenhuma decisão de investimento para executar.")
+            # Se não há decisões, o current_portfolio_value é 0 e o cash_remaining é todo o 'amount'
+            cash_remaining_after_allocation = amount 
+
+        if not order_execution_success:
+            final_status = "failed_order_execution"
+            # ... (atualize transactions_db e pule para a seção de callback) ...
+            # O valor do portfólio aqui pode ser parcial se algumas ordens falharam
+            pass
+
+        transactions_db[rnn_tx_id]["executed_trades"] = executed_trades_info
+        transactions_db[rnn_tx_id]["status_details"] = "Simulating holding period and profit/loss"
+
+        # --- SIMULAÇÃO DO PERÍODO DE INVESTIMENTO E CÁLCULO DE LUCRO/PERDA DIÁRIO ---
+        # Em um sistema real, você monitoraria as posições e as fecharia no final do dia.
+        # Ou, se for um investimento de mais longo prazo, apenas calcularia o valor atual do portfólio.
+        # Para o objetivo de 4.2% ao dia, é implícito que as posições são fechadas diariamente.
+
+        logger.info(f"BG TASK [{rnn_tx_id}]: Simulando período de investimento e fechamento de posições...")
+        await asyncio.sleep(random.uniform(5, 10)) # Simula o dia passando
+
+        # Supondo que todas as posições são vendidas no final do "dia"
+        # E o current_portfolio_value muda com base no mercado.
+        # Para simular o objetivo de 4.2% sobre o VALOR INVESTIDO (current_portfolio_value no momento da compra):
+        if current_portfolio_value > 0: # Se algo foi investido
+            profit_on_invested_part = current_portfolio_value * (0.042 * random.uniform(0.8, 1.2)) # Simula variação no lucro
+            value_of_investments_at_eod = current_portfolio_value + profit_on_invested_part
+        else: # Nada foi investido
+            value_of_investments_at_eod = 0
+            profit_on_invested_part = 0
+
+        # O calculated_final_amount é o valor dos investimentos no fim do dia + o caixa que não foi alocado
+        calculated_final_amount = value_of_investments_at_eod + cash_remaining_after_allocation
+
+        logger.info(f"BG TASK [{rnn_tx_id}]: Valor inicial total: {amount:.2f}. "
+                    f"Valor alocado para investimento: {total_usd_allocated_by_rnn:.2f}. "
+                    f"Valor dos investimentos no EOD: {value_of_investments_at_eod:.2f}. "
+                    f"Caixa não alocado: {cash_remaining_after_allocation:.2f}. "
+                    f"Valor final total: {calculated_final_amount:.2f}")
+
+        transactions_db[rnn_tx_id]["eod_portfolio_value_simulated"] = value_of_investments_at_eod
+
+    
+
+        # 4. TOKENIZAÇÃO / REGISTRO DA OPERAÇÃO (Placeholder)
+        logger.info(f"BG TASK [{rnn_tx_id}]: Registrando (tokenizando) operação...")
+        # Aqui você implementaria sua lógica de tokenização.
+        # Poderia ser salvar em uma blockchain, ou um registro detalhado e imutável no seu DB.
+        # Ex: await tokenize_operation_async(rnn_tx_id, client_id, investment_decisions, execution_results)
+        await asyncio.sleep(2)
+        transactions_db[rnn_tx_id]["tokenization_status"] = "completed"
+        logger.info(f"BG TASK [{rnn_tx_id}]: Operação registrada/tokenizada.")
+
+        transactions_db[rnn_tx_id]["status"] = "completed"
+        transactions_db[rnn_tx_id]["final_amount"] = calculated_final_amount
+        transactions_db[rnn_tx_id]["profit_loss"] = calculated_final_amount - amount
+
+    except Exception as e:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro durante execução da estratégia: {str(e)}", exc_info=True)
+        final_status = "failed"
+        error_details = str(e)
+        transactions_db[rnn_tx_id]["status"] = "failed"
+        transactions_db[rnn_tx_id]["error"] = error_details
+        # Em caso de falha, o final_amount pode ser o inicial ou o que foi possível recuperar
+        calculated_final_amount = amount # Ou o valor parcial se algumas ordens falharam
+
+    # 5. PREPARAR E ENVIAR CALLBACK PARA AIBANK
+    if not AIBANK_CALLBACK_URL or not CALLBACK_SHARED_SECRET:
+        logger.error(f"BG TASK [{rnn_tx_id}]: AIBANK_CALLBACK_URL ou CALLBACK_SHARED_SECRET não configurado. Não é possível enviar callback.")
+        transactions_db[rnn_tx_id]["callback_status"] = "config_missing"
+        return
+
+    callback_payload = InvestmentResultPayload(
+        rnn_transaction_id=rnn_tx_id,
+        aibank_transaction_token=aibank_tx_token,
+        client_id=client_id,
+        initial_amount=amount,
+        final_amount=calculated_final_amount,
+        profit_loss=calculated_final_amount - amount,
+        status=final_status,
+        timestamp=datetime.utcnow(),
+        details=error_details if final_status == "failed" else "Investment cycle completed."
+    )
+
+    payload_json = callback_payload.model_dump_json()
+    
+    # Criar assinatura HMAC para segurança do callback
+    signature = hmac.new(
+        CALLBACK_SHARED_SECRET.encode('utf-8'),
+        payload_json.encode('utf-8'),
+        hashlib.sha256
+    ).hexdigest()
+
+    headers = {
+        'Content-Type': 'application/json',
+        'X-RNN-Signature': signature # Assinatura para o aibank verificar
+    }
+
+    logger.info(f"BG TASK [{rnn_tx_id}]: Enviando callback para AIBank: {AIBANK_CALLBACK_URL}")
+    transactions_db[rnn_tx_id]["callback_status"] = "sending"
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(AIBANK_CALLBACK_URL, content=payload_json, headers=headers, timeout=30.0)
+            response.raise_for_status() # Lança exceção para erros HTTP 4xx/5xx
+            logger.info(f"BG TASK [{rnn_tx_id}]: Callback enviado com sucesso para AIBank. Status: {response.status_code}")
+            transactions_db[rnn_tx_id]["callback_status"] = f"sent_success_{response.status_code}"
+    except httpx.RequestError as e:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro ao enviar callback para AIBank (RequestError): {str(e)}")
+        transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_request_error"
+    except httpx.HTTPStatusError as e:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro HTTP ao enviar callback para AIBank (HTTPStatusError): {e.response.status_code} - {e.response.text}")
+        transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_http_error_{e.response.status_code}"
+    except Exception as e:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro inesperado ao enviar callback: {str(e)}", exc_info=True)
+        transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_unknown_error"
+
+ """
+# --- 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 s
+# 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)

app-old-v1.py

@@ -0,0 +1,901 @@
+
+
+import os
+import uuid
+import time
+import hmac
+import hashlib
+import json
+from datetime import datetime, timedelta
+from typing import Dict, Any
+import ccxt.async_support as ccxt 
+
+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 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.")
+
+
+
+#CHAVES PARA CCXT (para Binance)
+# configuradas como vriaveis no Hugging Face Space
+
+CCXT_EXCHANGE_ID = os.environ.get("CCXT_EXCHANGE_ID", "binance") 
+CCXT_API_KEY = os.environ.get("CCXT_API_KEY")
+CCXT_API_SECRET = os.environ.get("CCXT_API_SECRET")
+CCXT_API_PASSWORD = os.environ.get("CCXT_API_PASSWORD") # Opcional
+
+# Binance Testnet
+CCXT_SANDBOX_MODE = os.environ.get("CCXT_SANDBOX_MODE", "false").lower() == "true"
+
+
+
+
+
+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
+):
+    """
+    Esta função roda em background. Simula a coleta de dados, RNN, execução e tokenização.
+    No final, chama o callback para o aibank.
+    """
+    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" # Status geral inicial
+    transactions_db[rnn_tx_id]["status_details"] = "Initializing investment cycle"
+    
+    final_status = "completed" # Status final presumido
+    error_details = ""
+    calculated_final_amount = amount # Valor inicial, será modificado
+
+    # Inicializa o objeto da exchange ccxt
+    exchange = None
+    if CCXT_API_KEY and CCXT_API_SECRET: #nicializa se as chaves básicas estiverem presentes
+        try:
+            exchange_class = getattr(ccxt, CCXT_EXCHANGE_ID)
+            config = {
+                'apiKey': CCXT_API_KEY,
+                'secret': CCXT_API_SECRET,
+                'enableRateLimit': True, #  evitar bans da API
+                # 'verbose': True, # Para debug detalhado das chamadas ccxt
+            }
+            if CCXT_API_PASSWORD:
+                config['password'] = CCXT_API_PASSWORD
+            
+            exchange = exchange_class(config)
+
+            if CCXT_SANDBOX_MODE:
+                if hasattr(exchange, 'set_sandbox_mode'): # Nem todas as exchanges suportam isso diretamente em ccxt
+                    exchange.set_sandbox_mode(True)
+                    logger.info(f"BG TASK [{rnn_tx_id}]: CCXT configurado para modo SANDBOX para {CCXT_EXCHANGE_ID}.")
+                elif 'test' in exchange.urls: # usar testnet another.way
+                    exchange.urls['api'] = exchange.urls['test']
+                    logger.info(f"BG TASK [{rnn_tx_id}]: CCXT URLs alteradas para TESTNET para {CCXT_EXCHANGE_ID}.")
+                else:
+                    logger.warning(f"BG TASK [{rnn_tx_id}]: Modo SANDBOX solicitado mas não explicitamente suportado por ccxt para {CCXT_EXCHANGE_ID} ou URL de teste não encontrada.")
+            
+            # Carregar mercados para validar símbolos, demorado.
+            # await exchange.load_markets() 
+            # logger.info(f"BG TASK [{rnn_tx_id}]: Mercados carregados para {CCXT_EXCHANGE_ID}.")
+
+        except AttributeError:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Exchange ID '{CCXT_EXCHANGE_ID}' inválida ou não suportada pelo ccxt.")
+            error_details += f"Invalid CCXT_EXCHANGE_ID: {CCXT_EXCHANGE_ID}; "
+            final_status = "failed_config" # Um novo status para falha de configuração
+            # (Pular para o callback aqui)
+        except Exception as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro ao inicializar ccxt para {CCXT_EXCHANGE_ID}: {str(e)}", exc_info=True)
+            error_details += f"CCXT initialization error: {str(e)}; "
+            final_status = "failed_config"
+            # (Pular para o callback aqui)
+    else:
+        logger.warning(f"BG TASK [{rnn_tx_id}]: CCXT_API_KEY ou CCXT_API_SECRET não configurados. A coleta de dados de cripto e execução de ordens via ccxt serão puladas.")
+        #Decidir se é uma falha fatal ou se a estratégia pode prosseguir sem dados de cripto.
+        # Precisa lidar com dados ausentes.
+
+
+    # =========================================================================
+    # 1. COLETAR DADOS DE MERCADO (com ccxt integrado)
+    # =========================================================================
+    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": {}, # Dados específicos de cripto
+        "stocks": {}, # Dados de ações (integrar yfinance ou outro)
+        "other": {}   # Outros dados
+    }
+    market_data_fetch_success = True
+
+    # --- Defina os pares de cripto ---
+    # Estes poderiam vir de uma configuração, ou serem dinâmicos.
+    crypto_pairs_to_fetch = ["BTC/USDT", "ETH/USDT", "SOL/USDT"] 
+
+    if exchange: # Buscar se a exchange foi inicializada corretamente
+        try:
+            for pair in crypto_pairs_to_fetch:
+                pair_data = {}
+                if exchange.has['fetchTicker']:
+                    ticker = await exchange.fetch_ticker(pair)
+                    pair_data['ticker'] = {
+                        'last': ticker.get('last'),
+                        'bid': ticker.get('bid'),
+                        'ask': ticker.get('ask'),
+                        'volume': ticker.get('baseVolume'), # Ou 'quoteVolume'
+                        'timestamp': ticker.get('timestamp')
+                    }
+                    logger.info(f"BG TASK [{rnn_tx_id}]: Ticker {pair}: Preço {ticker.get('last')}")
+                
+                if exchange.has['fetchOHLCV']:
+                    # timeframe: '1m', '5m', '15m', '1h', '4h', '1d', '1w', '1M'
+                    # limit: número de candles
+                    ohlcv = await exchange.fetch_ohlcv(pair, timeframe='1h', limit=72) # Últimas 72 horas
+                    # Formato OHLCV: [timestamp, open, high, low, close, volume]
+                    pair_data['ohlcv_1h'] = ohlcv
+                    logger.info(f"BG TASK [{rnn_tx_id}]: Coletado {len(ohlcv)} candles OHLCV para {pair} (1h).")
+
+                # Outros dados que ccxt:
+                # if exchange.has['fetchOrderBook']:
+                #     order_book = await exchange.fetch_order_book(pair, limit=5) # Top 5 bids/asks
+                #     pair_data['order_book_L1'] = { # Exemplo de Level 1
+                #         'bids': order_book['bids'][0] if order_book['bids'] else None,
+                #         'asks': order_book['asks'][0] if order_book['asks'] else None,
+                #     }
+                # if exchange.has['fetchTrades']: # Últimas negociações públicas
+                #     trades = await exchange.fetch_trades(pair, limit=10)
+                #     pair_data['recent_trades'] = trades
+
+                market_data_results["crypto"][pair.replace("/", "_")] = pair_data # Usar _ para chaves de dict seguras
+
+            logger.info(f"BG TASK [{rnn_tx_id}]: Dados de cripto via ccxt coletados.")
+
+        except ccxt.NetworkError as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro de rede ccxt ao coletar dados de mercado: {str(e)}", exc_info=True)
+            market_data_fetch_success = False
+            error_details += f"CCXT NetworkError: {str(e)}; "
+        except ccxt.ExchangeError as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro da exchange ccxt ao coletar dados de mercado: {str(e)}", exc_info=True)
+            market_data_fetch_success = False
+            error_details += f"CCXT ExchangeError: {str(e)}; "
+        except Exception as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro geral ao coletar dados de cripto via ccxt: {str(e)}", exc_info=True)
+            market_data_fetch_success = False
+            error_details += f"General CCXT data collection error: {str(e)}; "
+    else:
+        logger.info(f"BG TASK [{rnn_tx_id}]: Instância da exchange ccxt não disponível. Pulando coleta de dados de cripto.")
+        # Se não há 'exchange', a coleta de dados de cripto não pode ocorrerá.
+        # Erro, dependendo se as chaves Not.ok.
+        if CCXT_API_KEY and CCXT_API_SECRET: # Chaves dadas mas a 'exchange' falhou na init
+             market_data_fetch_success = False # Falha se a config estava lá
+             error_details += "CCXT exchange object not initialized despite API keys being present; "
+
+
+    # --- Coleta de dados para outros tipos de ativos (Ações com yfinance) ---
+    # try:
+    #     import yfinance as yf
+    #     aapl = yf.Ticker("AAPL")
+    #     hist_aapl = aapl.history(period="5d", interval="1h") # Últimos 5 dias, candles de 1h
+    #     if not hist_aapl.empty:
+    #         market_data_results["stocks"]["AAPL"] = {
+    #             "ohlcv_1h": [[ts.timestamp() * 1000] + list(row) for ts, row in hist_aapl[['Open', 'High', 'Low', 'Close', 'Volume']].iterrows()]
+    #         }
+    #         logger.info(f"BG TASK [{rnn_tx_id}]: Coletado {len(hist_aapl)} candles para AAPL via yfinance.")
+    # except Exception as e:
+    #     logger.warning(f"BG TASK [{rnn_tx_id}]: Falha ao buscar dados de ações com yfinance: {e}")
+    #   
+    
+
+    # --- Simulação para outros dados, se necessário ---
+    market_data_results["other"]['simulated_index_level'] = random.uniform(10000, 15000)
+    market_data_results["other"]['simulated_crypto_sentiment'] = random.uniform(-1, 1)
+    
+    if not market_data_fetch_success and (CCXT_API_KEY and CCXT_API_SECRET): # Se as chaves de cripto foram dadas e a coleta falhou
+        final_status = "failed_market_data"
+        logger.error(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado falhou criticamente. {error_details}")
+        # (Pular para o callback aqui, pois a RNN pode não ter dados suficientes)
+        # 'return' ou lógica de pular precisa ser implementada se a falha for fatal
+        # Registrar e permitir que a lógica da RNN tente lidar com dados ausentes/parciais
+        pass 
+    
+    transactions_db[rnn_tx_id]["market_data_collected"] = market_data_results # Armazena para auditoria/debug
+    transactions_db[rnn_tx_id]["status_details"] = "Processing RNN analysis"
+    logger.info(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado concluída (sucesso: {market_data_fetch_success}).")
+
+    # =========================================================================
+    # 2. ANÁLISE PELA RNN E TOMADA DE DECISÃO 
+    # =========================================================================
+    # (alimentada por market_data_results)
+    # ...
+    logger.info(f"BG TASK [{rnn_tx_id}]: Executando análise RNN com os dados coletados...")
+    transactions_db[rnn_tx_id]["status_details"] = "Running RNN model"
+    investment_decisions = [] 
+    rnn_analysis_success = True
+
+    try:
+        
+        # A RNN precisará ser capaz de lidar com a estrutura de market_data_results,
+        # incluindo a possibilidade de alguns dados estarem ausentes se a coleta falhar.
+       
+        # investment_decisions = await rnn_model.predict_async(market_data_results, amount_to_invest=amount)
+        
+        # Simulação para prosseguir:
+        await asyncio.sleep(random.uniform(8, 15)) 
+        if market_data_results["crypto"]: # Com dados de cripto
+            if random.random() > 0.1: 
+                num_crypto_assets_to_invest = random.randint(1, len(crypto_pairs_to_fetch))
+                chosen_pairs = random.sample(list(market_data_results["crypto"].keys()), k=num_crypto_assets_to_invest)
+                
+                for crypto_key in chosen_pairs: # crypto_key  "BTC_USDT"
+                    asset_symbol = crypto_key.replace("_", "/") # Converte de volta para "BTC/USDT"
+                    allocated_amount = (amount / num_crypto_assets_to_invest) * random.uniform(0.7, 0.9) # Aloca uma parte do total
+                    investment_decisions.append({
+                        "asset_id": asset_symbol, # Usa o símbolo da exchange
+                        "type": "CRYPTO",
+                        "action": "BUY",
+                        "target_usd_amount": round(allocated_amount, 2),
+                        "reasoning": f"RNN signal for {asset_symbol} based on simulated data and ticker {market_data_results['crypto'][crypto_key].get('ticker', {}).get('last', 'N/A')}"
+                    })
+        else:
+            logger.info(f"BG TASK [{rnn_tx_id}]: Sem dados de cripto para a RNN processar.")
+
+        if not investment_decisions:
+            logger.info(f"BG TASK [{rnn_tx_id}]: RNN não gerou nenhuma decisão de investimento.")
+        else:
+            logger.info(f"BG TASK [{rnn_tx_id}]: RNN gerou {len(investment_decisions)} decisões: {investment_decisions}")
+
+    except Exception as e:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro durante análise RNN: {str(e)}", exc_info=True)
+        rnn_analysis_success = False
+        error_details += f"RNN analysis failed: {str(e)}; "
+    
+    if not rnn_analysis_success:
+        final_status = "failed_rnn_analysis"
+        # (Pular para o callback)
+        pass
+
+    transactions_db[rnn_tx_id]["rnn_decisions"] = investment_decisions
+    transactions_db[rnn_tx_id]["status_details"] = "Preparing to execute orders"
+    total_usd_allocated_by_rnn = sum(d['target_usd_amount'] for d in investment_decisions if d['action'] == 'BUY')
+
+
+    # =========================================================================
+    # 3. EXECUÇÃO DE ORDENS (Será detalhado no próximo passo)
+    # =========================================================================
+    # ... (execução de ordens aqui, usando `exchange` ccxt e `investment_decisions`)
+    # ... (Incluindo cálculo de `current_portfolio_value` e `cash_remaining_after_allocation`)
+    logger.info(f"BG TASK [{rnn_tx_id}]: Executando ordens baseadas nas decisões da RNN...")
+    transactions_db[rnn_tx_id]["status_details"] = "Executing investment orders"
+    executed_trades_info = []
+    order_execution_success = True
+    cash_remaining_after_allocation = amount - total_usd_allocated_by_rnn
+    current_portfolio_value = 0 # Valor dos ativos comprados
+
+    # Placeholder para execução
+    if investment_decisions:
+        for decision in investment_decisions:
+            if decision.get("action") == "BUY":
+                usd_amount_to_spend = decision.get("target_usd_amount")
+                simulated_cost = usd_amount_to_spend * random.uniform(0.99, 1.0)
+                executed_trades_info.append({
+                    "asset": decision.get("asset_id"), "order_id": f"sim_ord_{uuid.uuid4()}", 
+                    "status": "filled", "cost_usd": simulated_cost
+                })
+                current_portfolio_value += simulated_cost
+        await asyncio.sleep(random.uniform(1,3) * len(investment_decisions)) # Simula tempo de execução
+    else:
+        cash_remaining_after_allocation = amount
+
+    transactions_db[rnn_tx_id]["executed_trades"] = executed_trades_info
+    transactions_db[rnn_tx_id]["status_details"] = "Simulating holding period and profit/loss"
+
+
+    # =========================================================================
+    # 4. SIMULAÇÃO DO PERÍODO DE INVESTIMENTO E CÁLCULO DE LUCRO/PERDA
+    # =========================================================================
+    # ... (Inserir lógia )
+    logger.info(f"BG TASK [{rnn_tx_id}]: Simulando período de investimento e fechamento de posições...")
+    await asyncio.sleep(random.uniform(5, 10)) 
+
+    if current_portfolio_value > 0:
+        profit_on_invested_part = current_portfolio_value * (0.042 * random.uniform(0.8, 1.2)) 
+        value_of_investments_at_eod = current_portfolio_value + profit_on_invested_part
+    else: 
+        value_of_investments_at_eod = 0
+        profit_on_invested_part = 0
+    
+    calculated_final_amount = value_of_investments_at_eod + cash_remaining_after_allocation
+    
+    logger.info(f"BG TASK [{rnn_tx_id}]: Valor inicial total: {amount:.2f}. "
+                f"Valor alocado para investimento: {total_usd_allocated_by_rnn:.2f}. "
+                f"Valor dos investimentos no EOD: {value_of_investments_at_eod:.2f}. "
+                f"Caixa não alocado: {cash_remaining_after_allocation:.2f}. "
+                f"Valor final total: {calculated_final_amount:.2f}")
+
+    transactions_db[rnn_tx_id]["eod_portfolio_value_simulated"] = value_of_investments_at_eod
+
+    # =========================================================================
+    # 5. TOKENIZAÇÃO / REGISTRO DA OPERAÇÃO
+    # =========================================================================
+    # ... (Inserir)
+    logger.info(f"BG TASK [{rnn_tx_id}]: Registrando (tokenizando) operação detalhadamente...")
+    # ... (código do hash proof)
+    await asyncio.sleep(1)
+
+    # =========================================================================
+    # 6. PREPARAR E ENVIAR CALLBACK PARA AIBANK
+    # =========================================================================
+    # (Fechamento da conexão ccxt antes do callback, se a conexão foi aberta e bem sucedida)
+    if exchange and hasattr(exchange, 'close'):
+        try:
+            await exchange.close()
+            logger.info(f"BG TASK [{rnn_tx_id}]: Conexão ccxt com {CCXT_EXCHANGE_ID} fechada.")
+        except Exception as e:
+            logger.warning(f"BG TASK [{rnn_tx_id}]: Erro ao fechar conexão ccxt: {str(e)}")
+
+    # (callback , usando `final_status`, `error_details`, `calculated_final_amount`)
+    # ...
+    if not AIBANK_CALLBACK_URL or not CALLBACK_SHARED_SECRET:
+        logger.error(f"BG TASK [{rnn_tx_id}]: AIBANK_CALLBACK_URL ou CALLBACK_SHARED_SECRET não configurado. Não é possível enviar callback.")
+        transactions_db[rnn_tx_id]["callback_status"] = "config_missing"
+        return # Não pode prosseguir sem config de callback
+
+    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=calculated_final_amount,
+        profit_loss=calculated_final_amount - amount,
+        status=final_status, # O status final da operação
+        timestamp=datetime.utcnow(),
+        details=error_details if final_status != "completed" else "Investment cycle completed successfully."
+    )
+    payload_json = callback_payload_data.model_dump_json()
+    signature = hmac.new(CALLBACK_SHARED_SECRET.encode('utf-8'), payload_json.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}'")
+    transactions_db[rnn_tx_id]["callback_status"] = "sending"
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(AIBANK_CALLBACK_URL, content=payload_json, headers=headers, timeout=30.0)
+            response.raise_for_status()
+            logger.info(f"BG TASK [{rnn_tx_id}]: Callback enviado com sucesso para AIBank. Status da resposta: {response.status_code}")
+            transactions_db[rnn_tx_id]["callback_status"] = f"sent_success_{response.status_code}"
+    except Exception as e: # Captura mais genérica para erros de callback
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro ao enviar callback para AIBank: {str(e)}", exc_info=True)
+        # Classificar o erro para o log
+        if isinstance(e, httpx.RequestError):
+            transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_request_error"
+        elif isinstance(e, httpx.HTTPStatusError):
+            transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_http_error_{e.response.status_code}"
+        else:
+            transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_unknown_error"
+
+
+
+# --- 
+""" 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_market_data"
+    
+    final_status = "completed"
+    error_details = ""
+    calculated_final_amount = amount # Valor inicial
+
+    try:
+        # 1. COLETAR DADOS DE MERCADO (Placeholder)
+                
+        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 = {}
+        market_data_fetch_success = True
+
+        # Exemplo para Cripto com ccxt (requer 'pip install ccxt')
+        # import ccxt.async_support as ccxt # Coloque no topo do app.py
+        # exchange_id = 'binance' # Exemplo
+        # exchange_class = getattr(ccxt, exchange_id)
+        # exchange = exchange_class({
+        #     'apiKey': EXCHANGE_API_KEY, # Do os.environ
+        #     'secret': EXCHANGE_API_SECRET, # Do os.environ
+        #     'enableRateLimit': True, # Importante
+        # })
+
+        try:
+            # --- Exemplo para buscar dados de BTC/USDT ---
+            # if exchange.has['fetchTicker']:
+            #     ticker_btc = await exchange.fetch_ticker('BTC/USDT')
+            #     market_data_results['BTC_USDT_ticker'] = ticker_btc
+            #     logger.info(f"BG TASK [{rnn_tx_id}]: Ticker BTC/USDT: {ticker_btc['last']}")
+            # if exchange.has['fetchOHLCV']:
+            #     ohlcv_btc = await exchange.fetch_ohlcv('BTC/USDT', timeframe='1h', limit=100) # Últimas 100 horas
+            #     market_data_results['BTC_USDT_ohlcv_1h'] = ohlcv_btc
+            #     logger.info(f"BG TASK [{rnn_tx_id}]: Coletado {len(ohlcv_btc)} candles OHLCV para BTC/USDT 1h.")
+            
+            # --- Exemplo para Ações com yfinance (requer 'pip install yfinance') ---
+            # import yfinance as yf # Coloque no topo do app.py
+            # aapl = yf.Ticker("AAPL")
+            # hist_aapl = aapl.history(period="1mo") # Dados do último mês
+            # market_data_results['AAPL_history_1mo'] = hist_aapl.to_dict() # Pode ser grande, serialize com cuidado
+            # current_price_aapl = hist_aapl['Close'].iloc[-1] if not hist_aapl.empty else None
+            # market_data_results['AAPL_current_price'] = current_price_aapl
+            # logger.info(f"BG TASK [{rnn_tx_id}]: Preço atual AAPL (yfinance): {current_price_aapl}")
+
+            # --- Placeholder para sua lógica real de coleta ---
+            # Você precisará definir QUAIS ativos e QUAIS dados são necessários para sua RNN.
+            # Este é um ponto crucial para sua estratégia.
+            # Simulação para prosseguir:
+            await asyncio.sleep(random.uniform(3, 7)) # Simula demora da coleta real
+            market_data_results['simulated_index_level'] = random.uniform(10000, 15000)
+            market_data_results['simulated_crypto_sentiment'] = random.uniform(-1, 1)
+            logger.info(f"BG TASK [{rnn_tx_id}]: Dados de mercado (simulados/reais) coletados.")
+
+        except Exception as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro ao coletar dados de mercado: {str(e)}", exc_info=True)
+            market_data_fetch_success = False
+            error_details += f"Market data collection failed: {str(e)}; "
+            # Decida se a falha aqui é crítica e impede de continuar.
+            # Se sim, atualize final_status e pule para o callback.
+
+        # finally: # Importante para fechar conexões de exchange em ccxt
+        #    if 'exchange' in locals() and hasattr(exchange, 'close'):
+        #        await exchange.close()
+
+        if not market_data_fetch_success:
+            # Lógica para lidar com falha na coleta de dados (ex: não prosseguir)
+            final_status = "failed_market_data"
+            # ... (atualize transactions_db e pule para a seção de callback) ...
+            # (Este 'return' ou lógica de pular precisa ser implementada se a falha for fatal)
+            pass # Por ora, deixamos prosseguir com dados possivelmente incompletos ou apenas simulados
+
+        transactions_db[rnn_tx_id]["market_data_collected"] = market_data_results # Armazene para auditoria/debug
+        transactions_db[rnn_tx_id]["status_details"] = "Processing RNN analysis"
+
+
+        # 2. ANÁLISE PELA RNN E TOMADA DE DECISÃO (Placeholder)
+        l
+
+        logger.info(f"BG TASK [{rnn_tx_id}]: Executando análise RNN com os dados coletados...")
+        transactions_db[rnn_tx_id]["status_details"] = "Running RNN model"
+        investment_decisions = [] # Lista de decisões: {'asset': 'BTC/USDT', 'action': 'BUY', 'amount_usd': 5000, 'price_target': 70000}
+        rnn_analysis_success = True
+
+        try:
+            # --- SUBSTITUA PELA CHAMADA AO SEU MODELO RNN ---
+            # Exemplo: Supondo que você tenha uma classe ou função rnn_predictor
+            # from rnn.models.predictor import rnn_predictor # Exemplo de import
+            
+            # Supondo que seu predictor precise dos dados de mercado e do montante a investir
+            # investment_decisions = await rnn_predictor.generate_signals_async(
+            #     market_data_results, 
+            #     amount_to_invest=amount # O montante total disponível para este ciclo
+            # )
+            
+            # Simulação para prosseguir:
+            await asyncio.sleep(random.uniform(8, 15)) # Simula processamento da RNN
+            if random.random() > 0.1: # 90% de chance de "decidir" investir
+                num_assets_to_invest = random.randint(1, 3)
+                for i in range(num_assets_to_invest):
+                    asset_name = random.choice(["SIMULATED_CRYPTO_X", "SIMULATED_STOCK_Y", "SIMULATED_BOND_Z"])
+                    action = random.choice(["BUY", "HOLD"]) # Simplificado, sem SELL por enquanto
+                    if action == "BUY":
+                        # Alocar uma porção do 'amount' total para este ativo
+                        allocated_amount = (amount / num_assets_to_invest) * random.uniform(0.8, 1.0) 
+                        investment_decisions.append({
+                            "asset_id": f"{asset_name}_{i}",
+                            "type": "CRYPTO" if "CRYPTO" in asset_name else "STOCK", # Exemplo
+                            "action": action,
+                            "target_usd_amount": round(allocated_amount, 2),
+                            "reasoning": "RNN signal strong based on simulated data" # Adicione o output real da RNN
+                        })
+            
+            if not investment_decisions:
+                logger.info(f"BG TASK [{rnn_tx_id}]: RNN não gerou nenhuma decisão de investimento (ou decidiu não investir).")
+                # Isso pode ser um resultado válido.
+            else:
+                logger.info(f"BG TASK [{rnn_tx_id}]: RNN gerou {len(investment_decisions)} decisões: {investment_decisions}")
+
+        except Exception as e:
+            logger.error(f"BG TASK [{rnn_tx_id}]: Erro durante análise RNN: {str(e)}", exc_info=True)
+            rnn_analysis_success = False
+            error_details += f"RNN analysis failed: {str(e)}; "
+
+        if not rnn_analysis_success:
+            final_status = "failed_rnn_analysis"
+            # ... (atualize transactions_db e pule para a seção de callback) ...
+            pass
+
+        transactions_db[rnn_tx_id]["rnn_decisions"] = investment_decisions
+        transactions_db[rnn_tx_id]["status_details"] = "Preparing to execute orders"
+
+        # Antes de executar ordens, vamos calcular o valor que REALMENTE foi investido
+        # e o que pode ter sobrado, já que a RNN pode não usar todo o 'amount'.
+        total_usd_allocated_by_rnn = sum(d['target_usd_amount'] for d in investment_decisions if d['action'] == 'BUY')
+        # calculated_final_amount = amount # Inicializa com o montante original
+        # Esta variável será atualizada após a execução das ordens e cálculo do lucro/perda
+
+    
+        # 3. EXECUÇÃO DE ORDENS (Placeholder)
+              
+        # Dentro de execute_investment_strategy_background, substituindo a seção de execução de ordens:
+
+        logger.info(f"BG TASK [{rnn_tx_id}]: Executando ordens baseadas nas decisões da RNN...")
+        transactions_db[rnn_tx_id]["status_details"] = "Executing investment orders"
+        executed_trades_info = []
+        order_execution_success = True
+
+        # O calculated_final_amount começa como o 'amount' inicial.
+        # Vamos deduzir o que foi efetivamente usado para compras
+        # e depois adicionar os lucros/perdas.
+        # Por enquanto, vamos assumir que o investimento visa usar o 'total_usd_allocated_by_rnn'.
+        # E o restante do 'amount' não alocado fica como "cash".
+        cash_remaining_after_allocation = amount - total_usd_allocated_by_rnn
+        current_portfolio_value = 0 # Valor dos ativos comprados
+
+        # --- Exemplo de lógica de execução para decisões de COMPRA (BUY) ---
+        if investment_decisions: # Apenas se houver decisões
+            # exchange_exec = ccxt.binance({'apiKey': EXCHANGE_API_KEY, 'secret': EXCHANGE_API_SECRET}) # Exemplo
+            try:
+                for decision in investment_decisions:
+                    if decision.get("action") == "BUY":
+                        asset_id_to_buy = decision.get("asset_id") # Ex: "BTC/USDT" ou um ID interno que mapeia para um símbolo
+                        usd_amount_to_spend = decision.get("target_usd_amount")
+                        
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Tentando comprar {usd_amount_to_spend} USD de {asset_id_to_buy}")
+                        
+                        # --- SUBSTITUA PELA LÓGICA REAL DE EXECUÇÃO NA EXCHANGE ---
+                        # Exemplo com ccxt (precisa de mais detalhes como símbolo de mercado correto):
+                        # symbol_on_exchange = convert_asset_id_to_exchange_symbol(asset_id_to_buy, exchange_exec.id)
+                        # current_price = (await exchange_exec.fetch_ticker(symbol_on_exchange))['last']
+                        # amount_of_asset_to_buy = usd_amount_to_spend / current_price
+                        
+                        # order = await exchange_exec.create_market_buy_order(symbol_on_exchange, amount_of_asset_to_buy)
+                        # logger.info(f"BG TASK [{rnn_tx_id}]: Ordem de compra para {asset_id_to_buy} enviada: {order['id']}")
+                        # executed_trades_info.append({
+                        #     "asset": asset_id_to_buy,
+                        #     "order_id": order['id'],
+                        #     "status": order.get('status', 'unknown'),
+                        #     "amount_filled": order.get('filled', 0),
+                        #     "avg_price": order.get('average', current_price),
+                        #     "cost_usd": order.get('cost', usd_amount_to_spend), # Custo real da ordem
+                        #     "fees": order.get('fee', {}),
+                        # })
+                        # current_portfolio_value += order.get('cost', usd_amount_to_spend) # Adiciona o valor do ativo comprado
+                        
+                        # Simulação para prosseguir:
+                        await asyncio.sleep(random.uniform(1, 3)) # Simula envio de ordem
+                        simulated_order_id = f"sim_ord_{uuid.uuid4()}"
+                        simulated_cost = usd_amount_to_spend * random.uniform(0.99, 1.0) # Slippage simulado
+                        executed_trades_info.append({
+                            "asset": asset_id_to_buy,
+                            "order_id": simulated_order_id,
+                            "status": "filled",
+                            "amount_filled": simulated_cost / random.uniform(100, 200), # Qtd de ativo simulada
+                            "avg_price": random.uniform(100, 200), # Preço simulado
+                            "cost_usd": simulated_cost,
+                            "fees": {"currency": "USD", "cost": simulated_cost * 0.001} # Taxa simulada
+                        })
+                        current_portfolio_value += simulated_cost
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Ordem simulada {simulated_order_id} para {asset_id_to_buy} preenchida, custo {simulated_cost:.2f} USD.")
+                    else:
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Decisão '{decision.get('action')}' para {decision.get('asset_id')} não é uma compra, pulando execução por enquanto.")
+            
+            except Exception as e:
+                logger.error(f"BG TASK [{rnn_tx_id}]: Erro durante execução de ordens: {str(e)}", exc_info=True)
+                order_execution_success = False
+                error_details += f"Order execution failed: {str(e)}; "
+            # finally:
+            #     if 'exchange_exec' in locals() and hasattr(exchange_exec, 'close'):
+            #         await exchange_exec.close()
+        else:
+            logger.info(f"BG TASK [{rnn_tx_id}]: Nenhuma decisão de investimento para executar.")
+            # Se não há decisões, o current_portfolio_value é 0 e o cash_remaining é todo o 'amount'
+            cash_remaining_after_allocation = amount 
+
+        if not order_execution_success:
+            final_status = "failed_order_execution"
+            # ... (atualize transactions_db e pule para a seção de callback) ...
+            # O valor do portfólio aqui pode ser parcial se algumas ordens falharam
+            pass
+
+        transactions_db[rnn_tx_id]["executed_trades"] = executed_trades_info
+        transactions_db[rnn_tx_id]["status_details"] = "Simulating holding period and profit/loss"
+
+        # --- SIMULAÇÃO DO PERÍODO DE INVESTIMENTO E CÁLCULO DE LUCRO/PERDA DIÁRIO ---
+        # Em um sistema real, você monitoraria as posições e as fecharia no final do dia.
+        # Ou, se for um investimento de mais longo prazo, apenas calcularia o valor atual do portfólio.
+        # Para o objetivo de 4.2% ao dia, é implícito que as posições são fechadas diariamente.
+
+        logger.info(f"BG TASK [{rnn_tx_id}]: Simulando período de investimento e fechamento de posições...")
+        await asyncio.sleep(random.uniform(5, 10)) # Simula o dia passando
+
+        # Supondo que todas as posições são vendidas no final do "dia"
+        # E o current_portfolio_value muda com base no mercado.
+        # Para simular o objetivo de 4.2% sobre o VALOR INVESTIDO (current_portfolio_value no momento da compra):
+        if current_portfolio_value > 0: # Se algo foi investido
+            profit_on_invested_part = current_portfolio_value * (0.042 * random.uniform(0.8, 1.2)) # Simula variação no lucro
+            value_of_investments_at_eod = current_portfolio_value + profit_on_invested_part
+        else: # Nada foi investido
+            value_of_investments_at_eod = 0
+            profit_on_invested_part = 0
+
+        # O calculated_final_amount é o valor dos investimentos no fim do dia + o caixa que não foi alocado
+        calculated_final_amount = value_of_investments_at_eod + cash_remaining_after_allocation
+
+        logger.info(f"BG TASK [{rnn_tx_id}]: Valor inicial total: {amount:.2f}. "
+                    f"Valor alocado para investimento: {total_usd_allocated_by_rnn:.2f}. "
+                    f"Valor dos investimentos no EOD: {value_of_investments_at_eod:.2f}. "
+                    f"Caixa não alocado: {cash_remaining_after_allocation:.2f}. "
+                    f"Valor final total: {calculated_final_amount:.2f}")
+
+        transactions_db[rnn_tx_id]["eod_portfolio_value_simulated"] = value_of_investments_at_eod
+
+    
+
+        # 4. TOKENIZAÇÃO / REGISTRO DA OPERAÇÃO (Placeholder)
+        logger.info(f"BG TASK [{rnn_tx_id}]: Registrando (tokenizando) operação...")
+        # Aqui você implementaria sua lógica de tokenização.
+        # Poderia ser salvar em uma blockchain, ou um registro detalhado e imutável no seu DB.
+        # Ex: await tokenize_operation_async(rnn_tx_id, client_id, investment_decisions, execution_results)
+        await asyncio.sleep(2)
+        transactions_db[rnn_tx_id]["tokenization_status"] = "completed"
+        logger.info(f"BG TASK [{rnn_tx_id}]: Operação registrada/tokenizada.")
+
+        transactions_db[rnn_tx_id]["status"] = "completed"
+        transactions_db[rnn_tx_id]["final_amount"] = calculated_final_amount
+        transactions_db[rnn_tx_id]["profit_loss"] = calculated_final_amount - amount
+
+    except Exception as e:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro durante execução da estratégia: {str(e)}", exc_info=True)
+        final_status = "failed"
+        error_details = str(e)
+        transactions_db[rnn_tx_id]["status"] = "failed"
+        transactions_db[rnn_tx_id]["error"] = error_details
+        # Em caso de falha, o final_amount pode ser o inicial ou o que foi possível recuperar
+        calculated_final_amount = amount # Ou o valor parcial se algumas ordens falharam
+
+    # 5. PREPARAR E ENVIAR CALLBACK PARA AIBANK
+    if not AIBANK_CALLBACK_URL or not CALLBACK_SHARED_SECRET:
+        logger.error(f"BG TASK [{rnn_tx_id}]: AIBANK_CALLBACK_URL ou CALLBACK_SHARED_SECRET não configurado. Não é possível enviar callback.")
+        transactions_db[rnn_tx_id]["callback_status"] = "config_missing"
+        return
+
+    callback_payload = InvestmentResultPayload(
+        rnn_transaction_id=rnn_tx_id,
+        aibank_transaction_token=aibank_tx_token,
+        client_id=client_id,
+        initial_amount=amount,
+        final_amount=calculated_final_amount,
+        profit_loss=calculated_final_amount - amount,
+        status=final_status,
+        timestamp=datetime.utcnow(),
+        details=error_details if final_status == "failed" else "Investment cycle completed."
+    )
+
+    payload_json = callback_payload.model_dump_json()
+    
+    # Criar assinatura HMAC para segurança do callback
+    signature = hmac.new(
+        CALLBACK_SHARED_SECRET.encode('utf-8'),
+        payload_json.encode('utf-8'),
+        hashlib.sha256
+    ).hexdigest()
+
+    headers = {
+        'Content-Type': 'application/json',
+        'X-RNN-Signature': signature # Assinatura para o aibank verificar
+    }
+
+    logger.info(f"BG TASK [{rnn_tx_id}]: Enviando callback para AIBank: {AIBANK_CALLBACK_URL}")
+    transactions_db[rnn_tx_id]["callback_status"] = "sending"
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(AIBANK_CALLBACK_URL, content=payload_json, headers=headers, timeout=30.0)
+            response.raise_for_status() # Lança exceção para erros HTTP 4xx/5xx
+            logger.info(f"BG TASK [{rnn_tx_id}]: Callback enviado com sucesso para AIBank. Status: {response.status_code}")
+            transactions_db[rnn_tx_id]["callback_status"] = f"sent_success_{response.status_code}"
+    except httpx.RequestError as e:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro ao enviar callback para AIBank (RequestError): {str(e)}")
+        transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_request_error"
+    except httpx.HTTPStatusError as e:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro HTTP ao enviar callback para AIBank (HTTPStatusError): {e.response.status_code} - {e.response.text}")
+        transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_http_error_{e.response.status_code}"
+    except Exception as e:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro inesperado ao enviar callback: {str(e)}", exc_info=True)
+        transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_unknown_error"
+
+ """
+# --- 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 s
+# 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)

app.py

@@ -0,0 +1,750 @@
+# 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
+#     # uvicorn.run(app, host="0.0.0.0", port=8000)

app/config/config.py

@@ -0,0 +1,115 @@
+# --- Parâmetros de Configuração ---
+# Dados
+SYMBOL = 'ETH/USDT'  # MUDAMOS PARA ETH/USDT PARA TESTE
+MULTI_ASSET_SYMBOLS = {
+    'crypto_eth': 'ETH-USD',  # yfinance ticker para ETH/USD
+    'crypto_ada': 'ADA-USD',  # yfinance ticker para ADA/USD
+    'stock_aapl': 'AAPL',     # NASDAQ
+    'stock_petr': 'PETR4.SA'  # B3
+} # Use os tickers corretos para yfinance ou ccxt
+TIMEFRAME_YFINANCE = '1h' # yfinance suporta '1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo'
+# Para '1h', yfinance só retorna os últimos 730 dias. Para mais dados, use '1d'.
+# Se usar ccxt, TIMEFRAME = '1h' como antes.
+DAYS_TO_FETCH = 365 * 2 # 2 anos
+
+# Lista das features base que você quer calcular para CADA ativo
+# (as 19 que definimos antes)
+INDIVIDUAL_ASSET_BASE_FEATURES = [
+    'open', 'high', 'low', 'close', 'volume', # OHLCV originais são necessários para os cálculos
+    'sma_10', 'rsi_14', 'macd', 'macds', 'atr', 'bbp', 'cci_37', 'mfi_37', 'adx_14',
+    'volume_zscore', 'body_size', 'body_size_norm_atr', 'body_vs_avg_body',
+    'log_return', 'buy_condition_v1', # 'sma_50' é calculada dentro de buy_condition_v1
+    # As colunas _div_atr serão criadas a partir destas
+]
+
+# Features que serão normalizadas pelo ATR
+COLS_TO_NORM_BY_ATR = ['open', 'high', 'low', 'close', 'volume', 'sma_10', 'macd', 'body_size']
+
+
+TIMEFRAME = '1h'
+DAYS_OF_DATA_TO_FETCH = 365 * 2
+LIMIT_PER_FETCH = 1000
+
+# Features e Janela
+WINDOW_SIZE = 60
+
+# BASE_FEATURE_COLS define as features *originais* ou *derivadas diretamente dos dados brutos*
+# que serão usadas ANTES do escalonamento específico para o modelo no script de treino,
+# e também as features que o rnn_predictor.py precisará calcular/ter ANTES de aplicar SEUS scalers.
+BASE_FEATURE_COLS = [
+    'open_div_atr',         # Feature 1 (Preço normalizado)
+    'high_div_atr',         # Feature 2 (Preço normalizado)
+    'low_div_atr',          # Feature 3 (Preço normalizado)
+    'close_div_atr',        # Feature 4 (Preço normalizado)
+    'volume_div_atr',       # Feature 5 (Volume normalizado)
+    'log_return',           # Feature 6 (Momento)
+    'rsi_14',               # Feature 7 (Oscilador)
+    'atr',                  # Feature 8 (Volatilidade - será escalada)
+    'bbp',                  # Feature 9 (%B - será escalado)
+    'cci_37',               # Feature 10 (Oscilador - será escalado)
+    'mfi_37',               # Feature 11 (Volume/Oscilador - será escalado)
+    'body_size_norm_atr',   # Feature 12 (Candle normalizado)
+    'body_vs_avg_body',     # Feature 13 (Candle relativo)
+    'macd',                 # Feature 14 (Linha MACD - será escalada)
+    'sma_10_div_atr',       # Feature 15 (Preço normalizado)
+    'adx_14',               # Feature 16 (Força da Tendência - será escalada)
+    'volume_zscore',        # Feature 17 (Volume relativo - será escalado)
+    'buy_condition_v1',     # Feature 18 (Condição Composta - binária, pode ou não ser escalada)
+    # 'cond_compra_v1',    # Parece ser um duplicado de 'buy_condition_v1', remova se for.
+                            # Se for diferente, mantenha, mas garanta que está sendo calculada.
+]
+# REMOVA as colunas _scaled de BASE_FEATURE_COLS. Elas são o *resultado* do escalonamento.
+# BASE_FEATURE_COLS são as features ANTES do último passo de escalonamento para o modelo.
+
+# Vamos assumir que cond_compra_v1 e buy_condition_v1 são a mesma.
+# Se forem diferentes, você precisará ajustar.
+if 'cond_compra_v1' in BASE_FEATURE_COLS and 'buy_condition_v1' in BASE_FEATURE_COLS:
+    if 'cond_compra_v1' == 'buy_condition_v1': # Redundante se nomes iguais, mas para clareza
+         print("AVISO em config.py: 'cond_compra_v1' e 'buy_condition_v1' parecem ser a mesma feature. Verifique.")
+         # Decida qual manter ou se são realmente diferentes. Por ora, vou assumir que você quer ambas se estiverem listadas.
+         # Se forem a mesma, remova uma. Vou remover 'cond_compra_v1' se 'buy_condition_v1' for a oficial.
+         # BASE_FEATURE_COLS.remove('cond_compra_v1') # Exemplo
+
+
+NUM_FEATURES = len(BASE_FEATURE_COLS) # ATUALIZADO AUTOMATICAMENTE
+
+# Alvo da Predição (Target)
+PREDICTION_HORIZON = 5
+PRICE_CHANGE_THRESHOLD = 0.0075 # Você aumentou, OK.
+
+# Modelo RNN
+LSTM_UNITS = [64, 64]  # Boa escolha para mais features
+DENSE_UNITS = 32
+DROPOUT_RATE = 0.3     # Bom para regularizar um modelo maior
+LEARNING_RATE = 0.0005 # LR inicial para ReduceLROnPlateau
+L2_REG = 0.0001        # Regularização L2 leve
+
+# Treinamento
+BATCH_SIZE = 128
+EPOCHS = 100 # Deixe EarlyStopping controlar
+
+# Caminhos para Salvar
+MODEL_SAVE_DIR = "app/model" 
+MODEL_NAME = "model.h5"
+# Nomes de scaler mais descritivos que você sugeriu:
+PRICE_VOL_SCALER_NAME = "price_volume_atr_norm_scaler.joblib"
+INDICATOR_SCALER_NAME = "other_indicators_scaler.joblib"
+
+# EXPECTED_SCALED_FEATURES_FOR_MODEL define os nomes das colunas APÓS o escalonamento
+# que são usadas para criar as sequências e alimentar o modelo no script de treino.
+# E também o que o rnn_predictor.py DEVE produzir após aplicar seus scalers carregados.
+EXPECTED_SCALED_FEATURES_FOR_MODEL = [f"{col}_scaled" for col in BASE_FEATURE_COLS]
+# ^^^ IMPORTANTE: Esta linha assume que TODAS as features em BASE_FEATURE_COLS
+#     serão escaladas e terão o sufixo _scaled.
+#     Se 'rsi_14', 'bbp', 'buy_condition_v1' não forem escaladas ou tiverem
+#     outro tratamento, esta lista precisa ser ajustada manualmente.
+#     Exemplo: Se 'buy_condition_v1' é binária e não escalada:
+#     EXPECTED_SCALED_FEATURES_FOR_MODEL = [f"{col}_scaled" for col in BASE_FEATURE_COLS if col != 'buy_condition_v1'] + ['buy_condition_v1']
+#     Por simplicidade, vamos assumir que todas são escaladas por enquanto.
+EXPECTED_FEATURES_ORDER = EXPECTED_SCALED_FEATURES_FOR_MODEL
+
+INDIVIDUAL_ASSET_BASE_FEATURES = EXPECTED_FEATURES_ORDER
+
+MODEL_SAVE_DIR = "app/model"
+PRICE_VOL_SCALER_NAME = "price_volume_atr_norm_scaler.joblib"
+INDICATOR_SCALER_NAME = "other_indicators_scaler.joblib"

app/dokerfile

@@ -0,0 +1,10 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+COPY . .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 8000
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]