Update anchor count, API anchorage, mempool submodule and signet dashboard

**Motivations:**
- Update anchor count tracking
- Improve API anchorage Bitcoin RPC handling
- Update mempool submodule
- Enhance signet dashboard functionality and UI

**Root causes:**
- N/A (evolutions and updates)

**Correctifs:**
- N/A

**Evolutions:**
- Updated anchor count tracking
- Enhanced Bitcoin RPC handling in API anchorage
- Updated mempool submodule to latest version
- Added new features and improvements to signet dashboard (app.js, server.js)
- Enhanced signet dashboard UI (index.html, styles.css)

**Pages affectées:**
- anchor_count.txt
- api-anchorage/src/bitcoin-rpc.js
- api-anchorage/src/bitcoin-rpc.js.backup
- mempool (submodule)
- signet-dashboard/public/app.js
- signet-dashboard/public/index.html
- signet-dashboard/public/styles.css
- signet-dashboard/src/server.js

anchor_count.txt

@@ -1 +1 @@
-2026-01-25T00:20:14.085Z;6982;00000004b2ea52142ffebb57483d6aa53b9b21334e3067f00e54b5df506bf039;9088
+2026-01-25T01:33:13.690Z;7182;00000002fe6bb5f10aa5f01688bc0e6f862df0e4a4571babd2df5dd30d919b0b;9752

api-anchorage/src/bitcoin-rpc.js

@@ -253,6 +253,7 @@ class BitcoinRPC {
       const estimatedFeePerInput = 0.000001; // Estimation des frais par input (conservateur)
       const estimatedFeeBase = 0.00001; // Frais de base pour la transaction
       const maxChangeRatio = 10; // Maximum 10x le montant requis pour éviter un change trop grand
+      let sortedUnspent = [];
 
       // Sélectionner les UTXOs nécessaires pour couvrir le montant + frais
       const selectedUtxos = [];
@@ -269,7 +270,7 @@ class BitcoinRPC {
         totalSelected = 0;
 
         // Trier les UTXOs : d'abord ceux qui sont juste assez grands, puis les plus petits
-        const sortedUnspent = [...availableUtxos].sort((a, b) => {
+        sortedUnspent = [...availableUtxos].sort((a, b) => {
           // Préférer les UTXOs qui sont juste assez grands (pas trop grands)
           const aGood = a.amount >= totalNeeded && a.amount <= totalNeeded * maxChangeRatio;
           const bGood = b.amount >= totalNeeded && b.amount <= totalNeeded * maxChangeRatio;

api-anchorage/src/bitcoin-rpc.js.backup

@@ -0,0 +1,559 @@
+/**
+ * Client Bitcoin RPC
+ *
+ * Gère la connexion et les appels RPC vers le nœud Bitcoin Signet
+ */
+
+import Client from 'bitcoin-core';
+import { logger } from './logger.js';
+
+class BitcoinRPC {
+  constructor() {
+    this.client = new Client({
+      host: process.env.BITCOIN_RPC_HOST || 'localhost',
+      port: parseInt(process.env.BITCOIN_RPC_PORT || '38332'),
+      username: process.env.BITCOIN_RPC_USER || 'bitcoin',
+      password: process.env.BITCOIN_RPC_PASSWORD || 'bitcoin',
+      timeout: parseInt(process.env.BITCOIN_RPC_TIMEOUT || '30000'),
+    });
+
+    // Mutex pour gérer l'accès concurrent aux UTXOs
+    // Utilise une Promise-based queue pour sérialiser les accès
+    this.utxoMutexPromise = Promise.resolve();
+
+    // Liste des UTXOs en cours d'utilisation (format: "txid:vout")
+    this.lockedUtxos = new Set();
+  }
+
+  /**
+   * Acquiert le mutex pour l'accès aux UTXOs
+   * @returns {Promise<Function>} Fonction pour libérer le mutex
+   */
+  async acquireUtxoMutex() {
+    // Attendre que le mutex précédent soit libéré
+    const previousMutex = this.utxoMutexPromise;
+    let releaseMutex;
+
+    // Créer une nouvelle Promise qui sera résolue quand le mutex est libéré
+    this.utxoMutexPromise = new Promise((resolve) => {
+      releaseMutex = resolve;
+    });
+
+    // Attendre que le mutex précédent soit libéré
+    await previousMutex;
+
+    // Retourner la fonction pour libérer le mutex
+    return releaseMutex;
+  }
+
+  /**
+   * Vérifie si un UTXO est verrouillé
+   * @param {string} txid - ID de la transaction
+   * @param {number} vout - Index de l'output
+   * @returns {boolean} True si l'UTXO est verrouillé
+   */
+  isUtxoLocked(txid, vout) {
+    const key = `${txid}:${vout}`;
+    return this.lockedUtxos.has(key);
+  }
+
+  /**
+   * Verrouille un UTXO
+   * @param {string} txid - ID de la transaction
+   * @param {number} vout - Index de l'output
+   */
+  lockUtxo(txid, vout) {
+    const key = `${txid}:${vout}`;
+    this.lockedUtxos.add(key);
+    logger.debug('UTXO locked', { txid: txid.substring(0, 16) + '...', vout });
+  }
+
+  /**
+   * Verrouille plusieurs UTXOs
+   * @param {Array<Object>} utxos - Liste des UTXOs à verrouiller
+   */
+  lockUtxos(utxos) {
+    for (const utxo of utxos) {
+      this.lockUtxo(utxo.txid, utxo.vout);
+    }
+  }
+
+  /**
+   * Déverrouille un UTXO
+   * @param {string} txid - ID de la transaction
+   * @param {number} vout - Index de l'output
+   */
+  unlockUtxo(txid, vout) {
+    const key = `${txid}:${vout}`;
+    this.lockedUtxos.delete(key);
+    logger.debug('UTXO unlocked', { txid: txid.substring(0, 16) + '...', vout });
+  }
+
+  /**
+   * Déverrouille plusieurs UTXOs
+   * @param {Array<Object>} utxos - Liste des UTXOs à déverrouiller
+   */
+  unlockUtxos(utxos) {
+    for (const utxo of utxos) {
+      this.unlockUtxo(utxo.txid, utxo.vout);
+    }
+  }
+
+  /**
+   * Vérifie la connexion au nœud Bitcoin
+   * @returns {Promise<Object>} Informations sur le nœud
+   */
+  async checkConnection() {
+    try {
+      const networkInfo = await this.client.getNetworkInfo();
+      const blockchainInfo = await this.client.getBlockchainInfo();
+
+      return {
+        connected: true,
+        blocks: blockchainInfo.blocks,
+        chain: blockchainInfo.chain,
+        networkactive: networkInfo.networkactive,
+        connections: networkInfo.connections,
+      };
+    } catch (error) {
+      logger.error('Bitcoin RPC connection error', { error: error.message });
+      return {
+        connected: false,
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Obtient une nouvelle adresse depuis le wallet
+   * @returns {Promise<string>} Adresse Bitcoin
+   */
+  async getNewAddress() {
+    try {
+      return await this.client.getNewAddress();
+    } catch (error) {
+      logger.error('Error getting new address', { error: error.message });
+      throw new Error(`Failed to get new address: ${error.message}`);
+    }
+  }
+
+  /**
+   * Obtient le solde du wallet
+   * @returns {Promise<number>} Solde en BTC
+   */
+  async getBalance() {
+    try {
+      return await this.client.getBalance();
+    } catch (error) {
+      logger.error('Error getting balance', { error: error.message });
+      throw new Error(`Failed to get balance: ${error.message}`);
+    }
+  }
+
+  /**
+   * Crée une transaction d'ancrage
+   *
+   * @param {string} hash - Hash du document à ancrer (hex)
+   * @param {string} recipientAddress - Adresse de destination (optionnel, utilise getNewAddress si non fourni)
+   * @returns {Promise<Object>} Transaction créée avec txid
+   */
+  async createAnchorTransaction(hash, recipientAddress = null) {
+    // Acquérir le mutex pour l'accès aux UTXOs
+    const releaseMutex = await this.acquireUtxoMutex();
+    let selectedUtxos = [];
+
+    try {
+      // Vérifier que le hash est valide (64 caractères hex)
+      if (!/^[0-9a-fA-F]{64}$/.test(hash)) {
+        throw new Error('Invalid hash format. Must be 64 character hexadecimal string.');
+      }
+
+      // Obtenir une adresse de destination si non fournie
+      const address = recipientAddress || await this.getNewAddress();
+
+      // Obtenir le solde disponible
+      const balance = await this.getBalance();
+      const feeRate = parseFloat(process.env.MINING_FEE_RATE || '0.00001');
+
+      if (balance < feeRate) {
+        throw new Error(`Insufficient balance. Required: ${feeRate} BTC, Available: ${balance} BTC`);
+      }
+
+      // Créer une transaction avec le hash dans les données OP_RETURN
+      // Format: OP_RETURN + "ANCHOR:" + hash (32 bytes)
+      const hashBuffer = Buffer.from(hash, 'hex');
+      const anchorData = Buffer.concat([
+        Buffer.from('ANCHOR:', 'utf8'),
+        hashBuffer,
+      ]);
+
+      // Obtenir les UTXOs disponibles (inclure les non confirmés pour avoir plus d'options)
+      // Utiliser fetch directement avec l'URL RPC incluant le wallet pour éviter les problèmes de wallet
+      const walletName = process.env.BITCOIN_RPC_WALLET || 'custom_signet';
+      const host = process.env.BITCOIN_RPC_HOST || 'localhost';
+      const port = process.env.BITCOIN_RPC_PORT || '38332';
+      const username = process.env.BITCOIN_RPC_USER || 'bitcoin';
+      const password = process.env.BITCOIN_RPC_PASSWORD || 'bitcoin';
+      const rpcUrl = `http://${host}:${port}/wallet/${walletName}`;
+
+      // Utiliser Basic Auth dans les headers (fetch ne supporte pas les credentials dans l'URL)
+      const auth = Buffer.from(`${username}:${password}`).toString('base64');
+
+      const rpcResponse = await fetch(rpcUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Basic ${auth}`,
+        },
+        body: JSON.stringify({
+          jsonrpc: '1.0',
+          id: 'listunspent',
+          method: 'listunspent',
+          params: [0],
+        }),
+      });
+
+      if (!rpcResponse.ok) {
+        const errorText = await rpcResponse.text();
+        logger.error('HTTP error in listunspent', { status: rpcResponse.status, statusText: rpcResponse.statusText, response: errorText });
+        throw new Error(`HTTP error fetching UTXOs: ${rpcResponse.status} ${rpcResponse.statusText}`);
+      }
+
+      const rpcResult = await rpcResponse.json();
+      if (rpcResult.error) {
+        logger.error('RPC error in listunspent', { error: rpcResult.error });
+        throw new Error(`RPC error: ${rpcResult.error.message}`);
+      }
+      const unspent = rpcResult.result;
+
+      logger.info('Fetched UTXOs', { count: unspent.length, firstFew: unspent.slice(0, 3).map(u => ({ txid: u.txid.substring(0, 16), vout: u.vout, amount: u.amount })) });
+
+      if (unspent.length === 0) {
+        throw new Error('No unspent outputs available');
+      }
+
+      // Filtrer les UTXOs verrouillés (en cours d'utilisation par d'autres transactions)
+      const availableUtxos = unspent.filter(utxo => !this.isUtxoLocked(utxo.txid, utxo.vout));
+
+      logger.info('Available UTXOs (after filtering locked)', {
+        total: unspent.length,
+        available: availableUtxos.length,
+        locked: unspent.length - availableUtxos.length,
+        amounts: availableUtxos.map(u => u.amount).slice(0, 10),
+        largest: availableUtxos.length > 0 ? Math.max(...availableUtxos.map(u => u.amount)) : 0,
+      });
+
+      if (availableUtxos.length === 0) {
+        throw new Error('No available UTXOs (all are locked or in use)');
+      }
+
+      // Sélectionner plusieurs UTXOs si nécessaire (coin selection)
+      // Stratégie : préférer les UTXOs qui sont juste assez grands, puis combiner plusieurs petits UTXOs
+      const amount = 0.00001; // Montant minimal pour la transaction
+      const estimatedFeePerInput = 0.000001; // Estimation des frais par input (conservateur)
+      const estimatedFeeBase = 0.00001; // Frais de base pour la transaction
+      const maxChangeRatio = 10; // Maximum 10x le montant requis pour éviter un change trop grand
+
+      // Sélectionner les UTXOs nécessaires pour couvrir le montant + frais
+      const selectedUtxos = [];
+      let totalSelected = 0;
+
+      // Estimer le nombre d'inputs nécessaires (itération pour ajuster les frais)
+      let estimatedInputs = 1;
+      let totalNeeded = amount + estimatedFeeBase;
+
+      // Itérer jusqu'à trouver une combinaison qui fonctionne
+      for (let iteration = 0; iteration < 10; iteration++) {
+        totalNeeded = amount + estimatedFeeBase + (estimatedInputs * estimatedFeePerInput);
+        selectedUtxos.length = 0;
+        totalSelected = 0;
+
+        // Trier les UTXOs : d'abord ceux qui sont juste assez grands, puis les plus petits
+        const sortedUnspent = [...availableUtxos].sort((a, b) => {
+          // Préférer les UTXOs qui sont juste assez grands (pas trop grands)
+          const aGood = a.amount >= totalNeeded && a.amount <= totalNeeded * maxChangeRatio;
+          const bGood = b.amount >= totalNeeded && b.amount <= totalNeeded * maxChangeRatio;
+
+          if (aGood && !bGood) return -1;
+          if (!aGood && bGood) return 1;
+
+          // Sinon, trier par montant croissant pour minimiser le change
+          return a.amount - b.amount;
+        });
+
+        // Sélectionner les UTXOs jusqu'à avoir suffisamment de fonds
+        for (const utxo of sortedUnspent) {
+          if (totalSelected >= totalNeeded) {
+            break;
+          }
+
+          // Éviter les UTXOs trop grands qui créeraient un change énorme
+          // Sauf si c'est le seul UTXO disponible ou si on a déjà plusieurs UTXOs
+          if (selectedUtxos.length === 0 && utxo.amount > totalNeeded * maxChangeRatio) {
+            // Si c'est le premier UTXO et qu'il est trop grand, continuer à chercher
+            // Mais si c'est le seul disponible, l'utiliser quand même
+            continue;
+          }
+
+          selectedUtxos.push(utxo);
+          totalSelected += utxo.amount;
+        }
+
+        // Si on a assez de fonds, sortir de la boucle
+        if (totalSelected >= totalNeeded) {
+          break;
+        }
+
+        // Sinon, réessayer avec plus d'inputs estimés
+        estimatedInputs = selectedUtxos.length + 1;
+      }
+
+      // Vérifier qu'on a assez de fonds
+      if (totalSelected < totalNeeded) {
+        throw new Error(`Insufficient UTXO amount. Required: ${totalNeeded} BTC, Available: ${totalSelected} BTC. Selected ${selectedUtxos.length} UTXOs from ${sortedUnspent.length} available.`);
+      }
+
+      const now = new Date().toISOString();
+      logger.info('Selected UTXOs for transaction', {
+        hash: hash,
+        date: now,
+        count: selectedUtxos.length,
+        totalAmount: totalSelected,
+        required: totalNeeded,
+        change: totalSelected - totalNeeded,
+      });
+
+      // Verrouiller les UTXOs sélectionnés pour éviter qu'ils soient utilisés par d'autres transactions
+      this.lockUtxos(selectedUtxos);
+
+      // Créer la transaction raw avec les inputs et outputs (sans fundrawtransaction)
+      // Cela évite les erreurs de frais trop élevés avec la bibliothèque bitcoin-core
+      const inputs = selectedUtxos.map(utxo => ({
+        txid: utxo.txid,
+        vout: utxo.vout,
+      }));
+
+      // Calculer le change (monnaie restante après avoir payé le montant)
+      // Estimation des frais : base + (nombre d'inputs * frais par input)
+      const estimatedFee = estimatedFeeBase + (selectedUtxos.length * estimatedFeePerInput);
+      let change = totalSelected - amount - estimatedFee;
+
+      // Arrondir le change à 8 décimales (précision Bitcoin standard)
+      change = Math.round(change * 100000000) / 100000000;
+
+      // Créer les outputs
+      const outputs = {
+        data: anchorData.toString('hex'), // OP_RETURN output (doit être en premier)
+      };
+
+      // Ajouter l'output de destination avec le montant minimal (arrondi à 8 décimales)
+      outputs[address] = Math.round(amount * 100000000) / 100000000;
+
+      // Si le change est significatif (> 0.00001 BTC pour éviter les problèmes de précision), l'envoyer à une adresse de change
+      // Sinon, il sera considéré comme frais (dust)
+      if (change > 0.00001) {
+        const changeAddress = await this.getNewAddress();
+        outputs[changeAddress] = change;
+        logger.info('Adding change output', { changeAddress, change });
+      } else if (change > 0) {
+        logger.info('Change too small, will be included in fees', { change });
+      }
+
+      const tx = await this.client.command('createrawtransaction', inputs, outputs);
+
+      // Signer la transaction
+      // Utiliser command() directement pour éviter les problèmes avec la bibliothèque
+      const signedTx = await this.client.command('signrawtransactionwithwallet', tx);
+
+      if (!signedTx.complete) {
+        throw new Error('Transaction signing failed');
+      }
+
+      // Envoyer la transaction au mempool
+      // Utiliser command() avec maxfeerate comme deuxième paramètre (0 = accepter n'importe quel taux)
+      // Le test direct avec bitcoin-cli fonctionne avec cette syntaxe
+      const txid = await this.client.command('sendrawtransaction', signedTx.hex, 0);
+
+      logger.info('Anchor transaction sent to mempool', {
+        txid,
+        hash: hash.substring(0, 16) + '...',
+        address,
+      });
+
+      // Obtenir les informations de la transaction (dans le mempool)
+      const txInfo = await this.getTransactionInfo(txid);
+
+      // Déverrouiller les UTXOs maintenant que la transaction est dans le mempool
+      // Les UTXOs seront automatiquement marqués comme dépensés par Bitcoin Core
+      this.unlockUtxos(selectedUtxos);
+
+      // Libérer le mutex
+      releaseMutex();
+
+      return {
+        txid,
+        status: 'confirmed', // Transaction dans le mempool
+        confirmations: txInfo.confirmations || 0,
+        block_height: txInfo.blockheight || null, // null si pas encore dans un bloc
+      };
+    } catch (error) {
+      logger.error('Error creating anchor transaction', {
+        error: error.message,
+        hash: hash?.substring(0, 16) + '...',
+      });
+
+      // En cas d'erreur, déverrouiller les UTXOs et libérer le mutex
+      if (selectedUtxos.length > 0) {
+        this.unlockUtxos(selectedUtxos);
+      }
+      releaseMutex();
+
+      throw error;
+    }
+  }
+
+  /**
+   * Obtient les informations d'une transaction
+   * @param {string} txid - ID de la transaction
+   * @returns {Promise<Object>} Informations de la transaction
+   */
+  async getTransactionInfo(txid) {
+    try {
+      const tx = await this.client.getTransaction(txid);
+      const blockchainInfo = await this.client.getBlockchainInfo();
+
+      return {
+        txid: tx.txid,
+        confirmations: tx.confirmations || 0,
+        blockheight: tx.blockheight || null,
+        blockhash: tx.blockhash || null,
+        time: tx.time || null,
+        currentBlockHeight: blockchainInfo.blocks,
+      };
+    } catch (error) {
+      logger.error('Error getting transaction info', { error: error.message, txid });
+      throw new Error(`Failed to get transaction info: ${error.message}`);
+    }
+  }
+
+  /**
+   * Vérifie si un hash est ancré dans la blockchain
+   *
+   * @param {string} hash - Hash à vérifier
+   * @param {string} txid - ID de transaction optionnel pour accélérer la recherche
+   * @returns {Promise<Object>} Résultat de la vérification
+   */
+  async verifyAnchor(hash, txid = null) {
+    try {
+      // Vérifier que le hash est valide
+      if (!/^[0-9a-fA-F]{64}$/.test(hash)) {
+        throw new Error('Invalid hash format. Must be 64 character hexadecimal string.');
+      }
+
+      // Si un txid est fourni, vérifier directement cette transaction
+      if (txid) {
+        try {
+          const tx = await this.client.getTransaction(txid, true);
+          const rawTx = await this.client.getRawTransaction(txid, true);
+
+          // Vérifier si le hash est dans les outputs OP_RETURN
+          const hashFound = this.checkHashInTransaction(rawTx, hash);
+
+          if (hashFound) {
+            return {
+              verified: true,
+              anchor_info: {
+                transaction_id: txid,
+                block_height: tx.blockheight || null,
+                confirmations: tx.confirmations || 0,
+              },
+            };
+          }
+        } catch (error) {
+          // Si la transaction n'existe pas, continuer la recherche
+          logger.warn('Transaction not found, searching blockchain', { txid, error: error.message });
+        }
+      }
+
+      // Rechercher dans les blocs récents (derniers 100 blocs)
+      const blockchainInfo = await this.client.getBlockchainInfo();
+      const currentHeight = blockchainInfo.blocks;
+      const searchRange = 100; // Rechercher dans les 100 derniers blocs
+
+      for (let height = currentHeight; height >= Math.max(0, currentHeight - searchRange); height--) {
+        try {
+          const blockHash = await this.client.getBlockHash(height);
+          const block = await this.client.getBlock(blockHash, 2); // Verbose level 2
+
+          // Parcourir toutes les transactions du bloc
+          for (const tx of block.tx || []) {
+            try {
+              const rawTx = await this.client.getRawTransaction(tx.txid, true);
+              const hashFound = this.checkHashInTransaction(rawTx, hash);
+
+              if (hashFound) {
+                return {
+                  verified: true,
+                  anchor_info: {
+                    transaction_id: tx.txid,
+                    block_height: height,
+                    confirmations: currentHeight - height + 1,
+                  },
+                };
+              }
+            } catch (error) {
+              // Continuer avec la transaction suivante
+              logger.debug('Error checking transaction', { txid: tx.txid, error: error.message });
+            }
+          }
+        } catch (error) {
+          // Continuer avec le bloc suivant
+          logger.debug('Error checking block', { height, error: error.message });
+        }
+      }
+
+      // Hash non trouvé
+      return {
+        verified: false,
+        message: 'Hash not found in recent blocks',
+      };
+    } catch (error) {
+      logger.error('Error verifying anchor', { error: error.message, hash: hash?.substring(0, 16) + '...' });
+      throw error;
+    }
+  }
+
+  /**
+   * Vérifie si un hash est présent dans une transaction
+   * @param {Object} rawTx - Transaction brute
+   * @param {string} hash - Hash à rechercher
+   * @returns {boolean} True si le hash est trouvé
+   */
+  checkHashInTransaction(rawTx, hash) {
+    try {
+      // Parcourir les outputs de la transaction
+      for (const output of rawTx.vout || []) {
+        // Chercher dans les scripts OP_RETURN
+        if (output.scriptPubKey && output.scriptPubKey.hex) {
+          const scriptHex = output.scriptPubKey.hex;
+
+          // Vérifier si le script contient "ANCHOR:" suivi du hash
+          const anchorPrefix = Buffer.from('ANCHOR:', 'utf8').toString('hex');
+          const hashHex = hash.toLowerCase();
+
+          if (scriptHex.includes(anchorPrefix + hashHex)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    } catch (error) {
+      logger.error('Error checking hash in transaction', { error: error.message });
+      return false;
+    }
+  }
+}
+
+// Export class and singleton
+export { BitcoinRPC };
+export const bitcoinRPC = new BitcoinRPC();

signet-dashboard/public/app.js

@@ -33,6 +33,8 @@ async function loadData() {
             loadWalletBalance(),
             loadAnchorCount(),
             loadNetworkPeers(),
+            loadMiningDifficulty(),
+            loadAvgBlockTime(),
         ]);
 
         updateLastUpdateTime();
@@ -157,6 +159,77 @@ async function loadNetworkPeers() {
     }
 }
 
+/**
+ * Charge la difficulté de minage
+ */
+async function loadMiningDifficulty() {
+    try {
+        const response = await fetch(`${API_BASE_URL}/api/mining/difficulty`);
+        const data = await response.json();
+
+        if (data.difficulty !== undefined) {
+            // Formater la difficulté avec séparateurs de milliers
+            const formatted = formatDifficulty(data.difficulty);
+            document.getElementById('mining-difficulty').textContent = formatted;
+        } else {
+            document.getElementById('mining-difficulty').textContent = '-';
+        }
+    } catch (error) {
+        console.error('Error loading mining difficulty:', error);
+        document.getElementById('mining-difficulty').textContent = 'Erreur';
+    }
+}
+
+/**
+ * Charge le temps moyen entre blocs
+ */
+async function loadAvgBlockTime() {
+    try {
+        const response = await fetch(`${API_BASE_URL}/api/mining/avg-block-time`);
+        const data = await response.json();
+
+        if (data.formatted) {
+            document.getElementById('avg-block-time').textContent = data.formatted;
+        } else if (data.timeAvgSeconds !== undefined) {
+            document.getElementById('avg-block-time').textContent = formatBlockTime(data.timeAvgSeconds);
+        } else {
+            document.getElementById('avg-block-time').textContent = '-';
+        }
+    } catch (error) {
+        console.error('Error loading average block time:', error);
+        document.getElementById('avg-block-time').textContent = 'Erreur';
+    }
+}
+
+/**
+ * Formate la difficulté avec séparateurs de milliers
+ */
+function formatDifficulty(difficulty) {
+    if (difficulty === 0) return '0';
+    if (difficulty < 1) return difficulty.toFixed(4);
+    if (difficulty < 1000) return difficulty.toFixed(2);
+    if (difficulty < 1000000) return (difficulty / 1000).toFixed(2) + ' K';
+    if (difficulty < 1000000000) return (difficulty / 1000000).toFixed(2) + ' M';
+    return (difficulty / 1000000000).toFixed(2) + ' G';
+}
+
+/**
+ * Formate le temps moyen entre blocs en format lisible
+ */
+function formatBlockTime(seconds) {
+    if (seconds < 60) {
+        return `${seconds}s`;
+    } else if (seconds < 3600) {
+        const minutes = Math.floor(seconds / 60);
+        const secs = seconds % 60;
+        return secs > 0 ? `${minutes}m ${secs}s` : `${minutes}m`;
+    } else {
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+    }
+}
+
 /**
  * Formate un montant en BTC
  */

signet-dashboard/public/index.html

@@ -3,14 +3,19 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Bitcoin Signet - Dashboard de Supervision</title>
+    <title>Bitcoin Ancrage - Dashboard de Supervision</title>
     <link rel="stylesheet" href="styles.css">
 </head>
 <body>
     <div class="container">
         <header>
-            <h1>Bitcoin Signet - Dashboard de Supervision</h1>
+            <h1>Bitcoin Ancrage - Dashboard de Supervision</h1>
             <p class="subtitle">Surveillance de la blockchain et outils de test</p>
+            <p class="external-links">
+                <a href="https://mempool.4nkweb.com/fr/" target="_blank" rel="noopener noreferrer" class="external-link">
+                    🔗 Explorer Mempool
+                </a>
+            </p>
         </header>
 
         <main>
@@ -49,6 +54,14 @@
                         <h3>Nombre de Pairs</h3>
                         <p class="value" id="peer-count">-</p>
                     </div>
+                    <div class="card">
+                        <h3>Difficulté de Minage</h3>
+                        <p class="value" id="mining-difficulty">-</p>
+                    </div>
+                    <div class="card">
+                        <h3>Temps Moyen entre Blocs</h3>
+                        <p class="value" id="avg-block-time">-</p>
+                    </div>
                 </div>
             </section>
 
@@ -89,9 +102,9 @@
 
             <!-- Section Faucet -->
             <section class="faucet-section">
-                <h2>Faucet Bitcoin Signet</h2>
+                <h2>Faucet Bitcoin Ancrage</h2>
                 <div class="card">
-                    <p>Recevez 50 000 sats (0.0005 BTC) sur votre adresse Bitcoin Signet</p>
+                    <p>Recevez 50 000 ✅ (0.0005 🛡) sur votre adresse Bitcoin Ancrage</p>
                     <label for="faucet-address">Adresse Bitcoin :</label>
                     <input type="text" id="faucet-address" placeholder="tb1q..." pattern="^(tb1|bcrt1|2|3)[a-zA-HJ-NP-Z0-9]{25,62}$">
                     <button onclick="requestFaucet()">Demander des Sats</button>
@@ -101,7 +114,7 @@
         </main>
 
         <footer>
-            <p>Bitcoin Signet Dashboard - Équipe 4NK</p>
+            <p>Bitcoin Ancrage Dashboard - Équipe 4NK</p>
             <p>Dernière mise à jour : <span id="last-update">-</span></p>
         </footer>
     </div>

signet-dashboard/public/styles.css

@@ -49,6 +49,28 @@ header h1 {
     opacity: 0.9;
 }
 
+.external-links {
+    margin-top: 15px;
+}
+
+.external-link {
+    display: inline-block;
+    padding: 10px 20px;
+    background-color: rgba(255, 255, 255, 0.2);
+    color: white;
+    text-decoration: none;
+    border-radius: 5px;
+    font-size: 1em;
+    transition: background-color 0.3s, transform 0.2s;
+    border: 1px solid rgba(255, 255, 255, 0.3);
+}
+
+.external-link:hover {
+    background-color: rgba(255, 255, 255, 0.3);
+    transform: translateY(-2px);
+    text-decoration: none;
+}
+
 main {
     margin-bottom: 40px;
 }

signet-dashboard/src/server.js

@@ -198,6 +198,66 @@ app.get('/api/anchor/count', async (req, res) => {
   }
 });
 
+app.get('/api/mining/difficulty', async (req, res) => {
+  try {
+    const blockchainInfo = await bitcoinRPC.getBlockchainInfo();
+    const difficulty = blockchainInfo.difficulty || 0;
+    res.json({ difficulty });
+  } catch (error) {
+    logger.error('Error getting mining difficulty', { error: error.message });
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.get('/api/mining/avg-block-time', async (req, res) => {
+  try {
+    // Utiliser l'API mempool pour obtenir le temps moyen entre blocs
+    const mempoolUrl = process.env.MEMPOOL_API_URL || 'https://mempool.4nkweb.com';
+    const difficultyAdjustment = await makeHttpRequest(mempoolUrl, '/api/v1/difficulty-adjustment', {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (difficultyAdjustment.error) {
+      throw new Error(difficultyAdjustment.message || 'Failed to get difficulty adjustment');
+    }
+
+    // timeAvg est en millisecondes
+    const timeAvgMs = difficultyAdjustment.timeAvg || 0;
+    const timeAvgSeconds = Math.round(timeAvgMs / 1000);
+
+    res.json({
+      timeAvg: timeAvgMs,
+      timeAvgSeconds: timeAvgSeconds,
+      formatted: formatBlockTime(timeAvgSeconds)
+    });
+  } catch (error) {
+    logger.error('Error getting average block time', { error: error.message });
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * Formate le temps moyen entre blocs en format lisible
+ * @param {number} seconds - Temps en secondes
+ * @returns {string} Temps formaté
+ */
+function formatBlockTime(seconds) {
+  if (seconds < 60) {
+    return `${seconds}s`;
+  } else if (seconds < 3600) {
+    const minutes = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return secs > 0 ? `${minutes}m ${secs}s` : `${minutes}m`;
+  } else {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+  }
+}
+
 // Route pour générer un hash SHA256
 app.post('/api/hash/generate', (req, res) => {
   try {