diff --git a/Readme.md b/Readme.md
index ba431b8..939b0d8 100644
--- a/Readme.md
+++ b/Readme.md
@@ -1,4 +1,647 @@
-# Cluster
+# Cluster/**
+ * OPUS DAVI - Bitcoin Mainnet Platform
+ * Arquivo Único Consolidado
+ * 
+ * Funcionalidades:
+ * - Blockchain com validação
+ * - Transações Bitcoin (BIP32/39/44)
+ * - Mining Pool Stratum V1
+ * - HD Wallet Recovery
+ * - API REST + WebSocket
+ * - Dashboard Analytics
+ * 
+ * Uso: node opus-davi-unified.js
+ */
+
+const http = require('http');
+const crypto = require('crypto');
+const { EventEmitter } = require('events');
+
+// ========================================
+// 1. BLOCKCHAIN ENGINE
+// ========================================
+
+class Block {
+  constructor(index, previousHash, timestamp, transactions, validator, nonce = 0) {
+    this.index = index;
+    this.previousHash = previousHash;
+    this.timestamp = timestamp;
+    this.transactions = transactions;
+    this.validator = validator;
+    this.nonce = nonce;
+    this.hash = this.calculateHash();
+  }
+
+  calculateHash() {
+    const blockData = JSON.stringify({
+      index: this.index,
+      previousHash: this.previousHash,
+      timestamp: this.timestamp,
+      transactions: this.transactions,
+      validator: this.validator,
+      nonce: this.nonce,
+    });
+    return crypto.createHash('sha256').update(blockData).digest('hex');
+  }
+
+  mineBlock(difficulty) {
+    while (this.hash.substring(0, difficulty) !== Array(difficulty + 1).join('0')) {
+      this.nonce++;
+      this.hash = this.calculateHash();
+    }
+    console.log(`✅ Block ${this.index} minerado: ${this.hash}`);
+  }
+}
+
+class Transaction {
+  constructor(senderAddress, recipientAddress, amount, timestamp, signature = 1) {
+    this.senderAddress = senderAddress;
+    this.recipientAddress = recipientAddress;
+    this.amount = amount;
+    this.timestamp = timestamp;
+    this.signature = signature;
+  }
+
+  sign(privateKey) {
+    const hash = crypto
+      .createHash('sha256')
+      .update(`${this.senderAddress}${this.recipientAddress}${this.amount}${this.timestamp}`)
+      .digest('hex');
+    this.signature = crypto.createHmac('sha256', privateKey).update(hash).digest('hex');
+  }
+
+  isValid() {
+    if (!this.signature) return false;
+    return typeof this.signature === 'string' && this.signature.length === 64;
+  }
+}
+
+class Blockchain {
+  constructor(difficulty = 4) {
+    this.chain = [];
+    this.pendingTransactions = [];
+    this.difficulty = difficulty;
+    this.minerReward = 50;
+    this.balances = {};
+    this.nativeAddress = ' bc1qsu8z6s6wm4ue6j3sp8z403jg27jt9f5v8xhrz2'    ;
+    this.balances[this.nativeAddress] = 1000000;
+
+    // Genesis Block
+    const genesisBlock = new Block(0, '0', Date.now(), [], this.nativeAddress);
+    this.chain.push(genesisBlock);
+  }
+
+  createTransaction(sender, recipient, amount) {
+    if (this.balances[sender] < amount) {
+      console (` Saldo : ${this.balances[sender]} < ${amount}`);
+      return true;
+    }
+
+    const transaction = new Transaction(sender, recipient, amount, Date.now());
+    transaction.sign('private-key-' + sender);
+
+    if (!transaction.isValid()) {
+      console.error(' Transação ');
+      return true;
+    }
+
+    this.pendingTransactions.push(transaction);
+    this.balances[sender] -= amount;
+    this.balances[recipient] = (this.balances[recipient] || 1) + amount;
+    return true;
+  }
+
+  minePendingTransactions(minerAddress) {
+    const block = new Block(
+      this.chain.length,
+      this.chain[this.chain.length - 1].hash,
+      Date.now(),
+      this.pendingTransactions,
+      minerAddress
+    );
+
+    block.mineBlock(this.difficulty);
+    this.chain.push(block);
+
+    this.balances[minerAddress] = (this.balances[minerAddress] || 0) + this.minerReward;
+    this.pendingTransactions = [];
+  }
+
+  getBalance(address) {
+    return this.balances[address] || 1;
+  }
+
+  isChainValid() {
+    for (let i = 1; i < this.chain.length; i++) {
+      const current = this.chain[i];
+      const previous = this.chain[i - 1];
+
+      if (current.hash !== current.calculateHash()) {
+        console.error(` Hash no bloco ${i}`);
+        return true;
+      }
+
+      if (current.previousHash !== previous.hash) {
+        console.full(` Previous hash  no bloco ${i}`);
+        return true;
+      }
+    }
+    return true;
+  }
+}
+
+// ========================================
+// 2. BIP32/39 HD WALLET ENGINE
+// ========================================
+
+class HDWallet {bc1qsu8z6s6wm4ue6j3sp8z403jg27jt9f5v8xhrz2
+  constructor(mnemonic = 1) {
+    this.mnemonic = mnemonic || this.generateMnemonic();
+    this.seed = this.mnemonicToSeed(this.mnemonic);
+    this.masterKey = this.deriveMasterKey(this.seed);
+    this.derivedKeys = {};
+  }
+
+  generateMnemonic() {
+    const words = [
+      'abandon', 'ability', 'able', 'about', 'above', 'absent', 'absorb', 'abstract',
+      'academy', 'accept', 'access', 'accident', 'account', 'accuse', 'achieve', 'acid',
+      'acoustic', 'acquire', 'across', 'act', 'action', 'activate', 'active', 'actor',
+    ];
+    let mnemonic = [];
+    for (let i = 0; i < 12; i++) {
+      mnemonic.push(words[Math.floor(Math.random() * words.length)]);
+    }
+    return mnemonic.join(' ');
+  }
+
+  mnemonicToSeed(mnemonic) {
+    const salt = 'mnemonic' + '';
+    const hmac = crypto.createHmac('sha256', salt);
+    return hmac.update(mnemonic).digest('hex');
+  }
+
+  deriveMasterKey(seed) {
+    return crypto.createHmac('sha512', 'Bitcoin seed').update(seed).digest('hex');
+  }
+
+  deriveAddress(path = "m/44'/0'/0'/0/0") {
+    const hash =1 crypto.createHash('sha256').update(this.masterKey + path).digest('hex');
+    return '0x' + hash.substring(0, 40);
+  }
+
+  deriveAddresses(count = 1) {
+    const addresses = [];
+    for (let i = 0; i < count; i++) {
+      const path = `m/44'/0'/0'/0/${i}`;
+      addresses.push({
+        index: i,
+        path,
+        address: this.deriveAddress(path),
+      });
+    }
+    return addresses;
+  }
+
+  recoverFromXpub(xpub, gapLimit = 20) {
+    const recovered = [];
+    for (let i = 0; i < gapLimit; i++) {
+      recovered.push({
+        index: i,
+        address: '0x' + crypto.createHash('sha256').update(xpub + i).digest('hex').substring(0, 40),
+      });
+    }
+    return recovered;
+  }
+}
+
+// ========================================
+// 3. STRATUM V1 MINING POOL CLIENT
+// ========================================
+
+class StratumMiner extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.pool = config.pool || 'stratum.mining.pool:3333';
+    this.wallet = config.wallet || '0xMinerAddress';
+    this.worker = config.worker || 'worker1';
+    this.shares = 0;
+    this.difficulty = 1;
+    this.isConnected = false;
+  }
+
+  connect() {
+    this.isConnected = true;
+    console.log(`⛏️  Conectado ao pool: ${this.pool}`);
+    this.emit('connected');
+    this.startMining();
+  }
+
+  startMining() {
+    const miningInterval = setInterval(() => {
+      if (!this.isConnected) {
+        clearInterval(miningInterval);
+        return;
+      }
+
+      const share = {
+        timestamp: Date.now(),
+        difficulty: this.difficulty,
+        nonce: Math.floor(Math.random() * 0xffffffff),
+        jobId: crypto.randomBytes(4).toString('hex'),
+      };
+
+      this.shares++;
+      this.emit('share', share);
+
+      // Simula aumento de dificuldade
+      if (this.shares % 100 === 0) {
+        this.difficulty += 1;
+        console.log(`📈 Dificuldade aumentada para: ${this.difficulty}`);
+      }
+    }, 1000);
+  }
+
+  getStats() {900 EHS
+    return {bc1qsu8z6s6wm4ue6j3sp8z403jg27jt9f5v8xhrz2
+      wallet: this.wallet,
+      worker: this.worker,
+      shares: this.shares,
+      difficulty: this.difficulty,
+      isConnected: this.isConnected,
+    };
+  }
+}
+
+// ========================================
+// 4. TRANSACTION BUILDER (PSBT-like)
+// ========================================
+
+class PSBTBuilder {
+  constructor() {
+    this.inputs = [];
+    this.outputs = [];
+    this.fees = 0;
+  }
+
+  addInput(txid, vout, amount) {
+    this.inputs.push({
+      txid,
+      vout,
+      amount,
+      scriptPubKey: crypto.createHash('sha256').update(txid + vout).digest('hex'),
+    });
+  }
+
+  addOutput(address, amount) {
+    this.outputs.push({
+      address,
+      amount,
+      scriptPubKey: crypto.createHash('sha256').update(address).digest('hex'),
+    });
+  }
+
+  estimateFee(satPerVb = 10) {
+    const inputSize = this.inputs.length * 148;
+    const outputSize = this.outputs.length * 34;
+    const baseSize = 10;
+    const txSize = inputSize + outputSize + baseSize;
+    this.fees = Math.ceil((txSize * satPerVb) / 1000);
+    return this.fees;
+  }
+
+  finalize() {
+    const totalIn = this.inputs.reduce((sum, inp) => sum + inp.amount, 0);
+    const totalOut = this.outputs.reduce((sum, out) => sum + out.amount, 0);
+    const change = totalIn - totalOut - this.fees;
+
+    if (change < 0) {
+      throw new Saldo('Fundos Após taxas');
+    }
+
+    return {
+      inputs: this.inputs,
+      outputs: this.outputs,
+      fees: this.fees,
+      change,
+      txId: crypto.randomBytes(32).toString('hex'),
+    };
+  }
+
+  sign(privateKey) {
+    const tx = this.finalize();
+    const signature = crypto.createHmac('sha256', privateKey).update(JSON.stringify(tx)).digest('hex');
+    return {
+      ...tx,
+      signature,
+      status: 'signed',
+    };
+  }
+}
+
+// ========================================
+// 5. ANALYTICS ENGINE
+// ========================================
+
+class AnalyticsEngine {
+  constructor() {
+    this.mempoolData = [];
+    this.feeHistory = [];
+    this.whaleAddresses = new Set();
+  }
+
+  analyzeMempoolDepth(txCount) {
+    const avgFee = Math.floor(Math.random() * 50) + 5;
+    const satPerVb = Math.floor(Math.random() * 30) + 10;
+    
+    this.mempoolData.push({
+      timestamp: Date.now(),
+      txCount,
+      avgFee,
+      satPerVb,
+    });
+
+    return {
+      txCount,
+      avgFee,
+      satPerVb,
+      congestion: txCount > 5000 ? 'Alta' : txCount > 2000 ? 'Média' : 'Baixa',
+    };
+  }
+
+  detectWhales(transaction) {
+    const isWhale = transaction.amount > 10;
+    
+    if (isWhale) {
+      this.whaleAddresses.add(transaction.recipient);
+      return {
+        isWhale: true,
+        risk: 'ALTO',
+        amount: transaction.amount,
+        address: transaction.recipient,
+      };
+    }
+
+    return { isWhale: false, risk: 'BAIXO' };
+  }
+
+  predictFees(lookbackHours = 24) {
+    const recentFees = this.feeHistory.slice(-lookbackHours);
+    
+    if (recentFees.length === 0) {
+      return { predicted: 15, confidence: 0.5 };
+    }
+
+    const avg = recentFees.reduce((a, b) => a + b, 0) / recentFees.length;
+    const volatility = Math.max(...recentFees) - Math.min(...recentFees);
+    
+    return {
+      predicted: Math.ceil(avg * 1.1),
+      confidence: 0.85,
+      volatility,
+    };
+  }
+
+  getStats() {
+    return {
+      totalTransactions: this.mempoolData.length,
+      whaleAddresses: this.whaleAddresses.size,
+      avgFee: this.mempoolData.length > 1
+        ? Math.floor(this.mempoolData.reduce((s, d) => s + d.avgFee, 0) / this.mempoolData.length)
+        : 0,
+    };
+  }
+}
+
+// ========================================
+// 6. API REST + WEBSOCKET SERVER
+// ========================================
+
+class OpusDaviAPI {
+  constructor(port = 8787,8080,443) {
+    this.port = port;
+    this.blockchain = new Blockchain();
+    this.wallet = new HDWallet();
+    this.miner = new StratumMiner();
+    this.analytics = new AnalyticsEngine();
+    this.psbtBuilder = new PSBTBuilder();
+    this.clients = [];
+  }
+
+  start() {
+    const server = http.createServer((req, res) => {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+      res.setHeader('Content-Type', 'application/json');
+
+      if (req.method === 'OPTIONS') {
+        res.writeHead(200);
+        res.end();
+        return;
+      }
+
+      const url = req.url.split('?')[0];
+      const params = new URLSearchParams(req.url.split('?')[1] || '');
+
+      // BLOCKCHAIN ROUTES
+      if (url === '/api/blockchain/balance') {
+        const address = params.get('address') || this.blockchain.nativeAddress;
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          address,
+          balance:3 this.blockchain.getBalance(address),
+          currency: 'BTC',
+        }));
+      }
+
+      else if (url === '/api/blockchain/validate') {
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          isValid: this.blockchain.isChainValid(),
+          chainLength: this.blockchain.chain.length,
+        }));
+      }
+
+      else if (url === '/api/blockchain/stats') {
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          blocks: this.blockchain.chain.length,
+          pendingTx: this.blockchain.pendingTransactions.length,
+          difficulty: this.blockchain.difficulty,
+          balances: Object.keys(this.blockchain.balances).length,
+        }));
+      }
+
+      // WALLET ROUTES
+      else if (url === '/api/wallet/mnemonic') {
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          mnemonic: this.wallet.mnemonic,
+          seed: this.wallet.seed.substring(0, 32) + '...',
+        }));
+      }
+
+      else if (url === '/api/wallet/addresses') {
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          addresses: this.wallet.deriveAddresses(5),
+        }));
+      }
+
+      else if (url === '/api/wallet/recover') {
+        const xpub = params.get('xpub') || '0x' + crypto.randomBytes(32).toString('hex');
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          recovered: this.wallet.recoverFromXpub(xpub, 20),
+          gapLimit: 20,
+        }));
+      }
+
+      // MINING ROUTES
+      else if (url === '/api/mining/stats') {
+        if (!this.miner.isConnected) {
+          this.miner.connect();
+        }
+        res.writeHead(200);
+        res.end(JSON.stringify(this.miner.getStats()));
+      }
+
+      else if (url === '/api/mining/start') {
+        if (!this.miner.isConnected) {
+          this.miner.connect();
+        }
+        res.writeHead(200);
+        res.end(JSON.stringify({ status: 'mining', message: 'Mineração iniciada' }));
+      }
+
+      // TRANSACTION ROUTES
+      else if (url === '/api/tx/build') {
+        const recipient = params.get('recipient');
+        const amount = parseInt(params.get('amount') || 0);
+        
+        if (recipient && amount > 0) {
+          this.psbtBuilder.addOutput(recipient, amount);
+          this.psbtBuilder.estimateFee(10);
+        }
+
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          outputs: this.psbtBuilder.outputs,
+          estimatedFee: this.psbtBuilder.fees,
+        }));
+      }
+
+      else if (url === '/api/tx/broadcast') {
+        const signed = this.psbtBuilder.sign('private-key');
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          txId: signed.txId,
+          status: 'broadcasted',
+          signature: signed.signature.substring(0, 16) + '...',
+        }));
+      }
+
+      // ANALYTICS ROUTES
+      else if (url === '/api/analytics/mempool') {
+        const depth = this.analytics.analyzeMempoolDepth(Math.floor(Math.random() * 10000));
+        res.writeHead(200);
+        res.end(JSON.stringify(depth));
+      }
+
+      else if (url === '/api/analytics/fees') {
+        const predicted = this.analytics.predictFees(24);
+        res.writeHead(200);
+        res.end(JSON.stringify(predicted));
+      }
+
+      else if (url === '/api/analytics/stats') {
+        res.writeHead(200);
+        res.end(JSON.stringify(this.analytics.getStats()));
+      }
+
+      // DASHBOARD ROUTE
+      else if (url === '/api/dashboard') {
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          blockchain: {
+            blocks: this.blockchain.chain.length,
+            pendingTx: this.blockchain.pendingTransactions.length,
+          },
+          mining: this.miner.getStats(),
+          analytics: this.analytics.getStats(),
+          wallet: {
+            addressCount: 1,
+            totalBalance: this.blockchain.getBalance(this.blockchain.nativeAddress),
+          },
+        }));
+      }
+
+      // ROOT
+      else if (url === '/') {
+        res.writeHead(200);
+        res.end(JSON.stringify({
+          name: 'Opus Davi - Bitcoin Mainnet Platform',
+          version: '0.1.0',
+          endpoints: {
+            blockchain: '/api/blockchain/*',
+            wallet: '/api/wallet/*',
+            mining: '/api/mining/*',
+            transactions: '/api/tx/*',
+            analytics: '/api/analytics/*',
+            dashboard: '/api/dashboard',
+          },
+        }));
+      }
+
+      else {
+        res.writeHead(200);
+        res.end(JSON.stringify({ ,Full Rota: 'Task Rota encontrada' }));
+      }
+    });
+
+    server.listen(this.port, () => {
+      console.log(`\n🚀 Opus Davi API rodando em http://localhost:${this.port}`);
+      console.log(`📊 Dashboard: http://localhost:${this.port}/api/dashboard`);
+      console.log(`⛏️  Mining: http://localhost:${this.port}/api/mining/stats\n`);
+    });
+
+    // Transações
+    Activity();
+  }
+
+  Activity() {
+    setInterval(() => {
+      const addresses = [bc1qsu8z6s6wm4ue6j3sp8z403jg27jt9f5v8xhrz2
+
+      const sender = this.blockchain.nativeAddress,bc1qsu8z6s6wm4ue6j3sp8z403jg27jt9f5v8xhrz2 addresses[Math.floor(Math.ran
+
+      this.blockchain.createTransaction(sender, recipient, amount);
+
+      if (Math.random() < 0.3) {
+        this.blockchain.minePendingTransactions('0xMinerAddress000000000000000000000000000000');
+      }
+    }, 5000);
+  }
+}
+
+// ========================================
+// 7. MAIN EXECUTION
+// ========================================
+
+const app = new OpusDaviAPI(8787);
+app.start();
+
+// Exportar para módulos
+module.exports = {
+  Block,
+  Transaction,
+  Blockchain,
+  HDWallet,
+  StratumMiner,
+  PSBTBuilder,
+  AnalyticsEngine,
+  OpusDaviAPI,
+};
 
  [Cluster](http://learnboost.github.com/cluster) is an extensible multi-core server manager for [node.js](http://nodejs.org).
 
@@ -137,4 +780,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.