BlockchainAPI.js

const axios = require('axios');

class BlockchainAPI {
  constructor(cacheDuration = 60000) {
    this.baseURL = 'https://blockchain.info';
    this.cache = new Map();
    this.cacheDuration = cacheDuration; // Default: 1 minute
  }

  /**
   * Get cached data or fetch new data
   * @private
   */
  _getCached(key, fetchFunction) {
    const cached = this.cache.get(key);
    if (cached && Date.now() - cached.timestamp < this.cacheDuration) {
      return Promise.resolve(cached.data);
    }

    return fetchFunction().then(data => {
      this.cache.set(key, { data, timestamp: Date.now() });
      return data;
    });
  }

  /**
   * Clear all cached data
   */
  clearCache() {
    this.cache.clear();
  }

  /**
   * Clear cache for specific key
   */
  clearCacheKey(key) {
    this.cache.delete(key);
  }

  /**
   * Add delay between requests
   * @private
   */
  _delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  /**
   * Get balance for a single address in BTC
   * @param {string} address - Bitcoin address
   * @returns {Promise<number>} Balance in BTC
   */
  async getAddressBalance(address) {
    const cacheKey = `balance_${address}`;
    return this._getCached(cacheKey, async () => {
      try {
        const response = await axios.get(`${this.baseURL}/q/addressbalance/${address}`);
        const satoshis = parseInt(response.data);
        return satoshis / 100000000; // Convert to BTC
      } catch (error) {
        console.error('Error fetching balance:', error.message);
        throw error;
      }
    });
  }

  /**
   * Get detailed information about an address
   * @param {string} address - Bitcoin address
   * @param {number} limit - Number of transactions to return (default: 50)
   * @returns {Promise<Object>} Address details including transactions
   */
  async getAddressDetails(address, limit = 50) {
    const cacheKey = `details_${address}_${limit}`;
    return this._getCached(cacheKey, async () => {
      try {
        const response = await axios.get(
          `${this.baseURL}/rawaddr/${address}?limit=${limit}`
        );
        return response.data;
      } catch (error) {
        console.error('Error fetching address details:', error.message);
        throw error;
      }
    });
  }

  /**
   * Get balances for multiple addresses
   * @param {string[]} addresses - Array of Bitcoin addresses
   * @returns {Promise<Object>} Object with addresses as keys
   */
  async getMultipleBalances(addresses) {
    const cacheKey = `multi_${addresses.sort().join('|')}`;
    return this._getCached(cacheKey, async () => {
      try {
        const addressString = addresses.join('|');
        const response = await axios.get(
          `${this.baseURL}/balance?active=${addressString}`
        );
        return response.data;
      } catch (error) {
        console.error('Error fetching multiple balances:', error.message);
        throw error;
      }
    });
  }

  /**
   * Get unspent transaction outputs (UTXOs) for an address
   * @param {string} address - Bitcoin address
   * @returns {Promise<Object>} Unspent outputs
   */
  async getUnspentOutputs(address) {
    const cacheKey = `unspent_${address}`;
    return this._getCached(cacheKey, async () => {
      try {
        const response = await axios.get(
          `${this.baseURL}/unspent?active=${address}`
        );
        return response.data;
      } catch (error) {
        console.error('Error fetching unspent outputs:', error.message);
        throw error;
      }
    });
  }

  /**
   * Get transaction details
   * @param {string} txHash - Transaction hash
   * @returns {Promise<Object>} Transaction details
   */
  async getTransaction(txHash) {
    const cacheKey = `tx_${txHash}`;
    return this._getCached(cacheKey, async () => {
      try {
        const response = await axios.get(`${this.baseURL}/rawtx/${txHash}`);
        return response.data;
      } catch (error) {
        console.error('Error fetching transaction:', error.message);
        throw error;
      }
    });
  }

  /**
   * Get latest block information
   * @returns {Promise<Object>} Latest block data
   */
  async getLatestBlock() {
    const cacheKey = 'latest_block';
    return this._getCached(cacheKey, async () => {
      try {
        const response = await axios.get(`${this.baseURL}/latestblock`);
        return response.data;
      } catch (error) {
        console.error('Error fetching latest block:', error.message);
        throw error;
      }
    });
  }

  /**
   * Get block at specific height
   * @param {number} height - Block height
   * @returns {Promise<Object>} Block data
   */
  async getBlockAtHeight(height) {
    const cacheKey = `block_height_${height}`;
    return this._getCached(cacheKey, async () => {
      try {
        const response = await axios.get(
          `${this.baseURL}/block-height/${height}?format=json`
        );
        return response.data;
      } catch (error) {
        console.error('Error fetching block:', error.message);
        throw error;
      }
    });
  }

  /**
   * Batch fetch balances with delay between requests
   * @param {string[]} addresses - Array of Bitcoin addresses
   * @param {number} delayMs - Delay between requests in milliseconds (default: 1000)
   * @returns {Promise<Array>} Array of balances
   */
  async batchFetchBalances(addresses, delayMs = 1000) {
    const results = [];
    for (const address of addresses) {
      results.push(await this.getAddressBalance(address));
      if (addresses.indexOf(address) < addresses.length - 1) {
        await this._delay(delayMs);
      }
    }
    return results;
  }

  /**
   * Format satoshis to BTC
   * @param {number} satoshis - Amount in satoshis
   * @returns {number} Amount in BTC
   */
  satoshisToBTC(satoshis) {
    return satoshis / 100000000;
  }

  /**
   * Format BTC amount with proper decimals
   * @param {number} btc - Amount in BTC
   * @returns {string} Formatted BTC string
   */
  formatBTC(btc) {
    return btc.toFixed(8) + ' BTC';
  }

  /**
   * Get cache statistics
   * @returns {Object} Cache stats
   */
  getCacheStats() {
    return {
      size: this.cache.size,
      duration: this.cacheDuration,
      keys: Array.from(this.cache.keys())
    };
  }
}

module.exports = BlockchainAPI;