21438530a1
**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
560 lines
20 KiB
Plaintext
560 lines
20 KiB
Plaintext
/**
|
|
* 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();
|