api-server.js

const express = require('express');
const BlockchainAPI = require('./BlockchainAPI');

const app = express();
const api = new BlockchainAPI(30000); // 30 second cache for real-time data
const PORT = process.env.PORT || 3000;

app.use(express.json());

// Helper function to calculate percentage change
function calculatePercentageChange(oldValue, newValue) {
  if (oldValue === 0) return 0;
  return ((newValue - oldValue) / oldValue) * 100;
}

// Helper function to group transactions by month
function groupTransactionsByMonth(transactions) {
  const monthlyData = {};

  transactions.forEach(tx => {
    const date = new Date(tx.time * 1000);
    const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;

    if (!monthlyData[monthKey]) {
      monthlyData[monthKey] = {
        month: monthKey,
        transactionCount: 0,
        totalValue: 0,
        transactions: []
      };
    }

    let txValue = 0;
    tx.out.forEach(output => {
      txValue += output.value;
    });

    monthlyData[monthKey].transactionCount++;
    monthlyData[monthKey].totalValue += txValue;
    monthlyData[monthKey].transactions.push(tx.hash);
  });

  return Object.values(monthlyData).sort((a, b) => a.month.localeCompare(b.month));
}

// Route 1: Bitcoin Month-over-Month trend
app.get('/bitcoin/mom', async (req, res) => {
  try {
    const latestBlock = await api.getLatestBlock();
    const currentHeight = latestBlock.height;

    // Approximate blocks per month (144 blocks/day * 30 days)
    const blocksPerMonth = 144 * 30;

    const currentMonthBlock = await api.getBlockAtHeight(currentHeight);
    const lastMonthBlock = await api.getBlockAtHeight(currentHeight - blocksPerMonth);
    const twoMonthsAgoBlock = await api.getBlockAtHeight(currentHeight - (blocksPerMonth * 2));

    const currentMonth = currentMonthBlock.blocks[0];
    const lastMonth = lastMonthBlock.blocks[0];
    const twoMonthsAgo = twoMonthsAgoBlock.blocks[0];

    // Calculate transaction count trend
    const currentTxCount = currentMonth.n_tx || currentMonth.tx.length;
    const lastMonthTxCount = lastMonth.n_tx || lastMonth.tx.length;
    const twoMonthsAgoTxCount = twoMonthsAgo.n_tx || twoMonthsAgo.tx.length;

    const txCountChange = calculatePercentageChange(lastMonthTxCount, currentTxCount);
    const previousTxCountChange = calculatePercentageChange(twoMonthsAgoTxCount, lastMonthTxCount);

    res.json({
      success: true,
      data: {
        currentBlockHeight: currentHeight,
        monthOverMonth: {
          transactionCount: {
            current: currentTxCount,
            lastMonth: lastMonthTxCount,
            twoMonthsAgo: twoMonthsAgoTxCount,
            changePercent: txCountChange.toFixed(2),
            trend: txCountChange > 0 ? 'up' : txCountChange < 0 ? 'down' : 'stable',
            previousChangePercent: previousTxCountChange.toFixed(2)
          },
          blockInfo: {
            current: {
              height: currentHeight,
              time: new Date(currentMonth.time * 1000).toISOString(),
              size: currentMonth.size
            },
            lastMonth: {
              height: currentHeight - blocksPerMonth,
              time: new Date(lastMonth.time * 1000).toISOString(),
              size: lastMonth.size
            }
          }
        }
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// Route 2: Bitcoin history (recent blocks)
app.get('/bitcoin/history', async (req, res) => {
  try {
    const limit = parseInt(req.query.limit) || 10;
    const latestBlock = await api.getLatestBlock();
    const currentHeight = latestBlock.height;

    const history = [];

    for (let i = 0; i < limit; i++) {
      const blockData = await api.getBlockAtHeight(currentHeight - i);
      const block = blockData.blocks[0];

      history.push({
        height: currentHeight - i,
        hash: block.hash,
        time: new Date(block.time * 1000).toISOString(),
        transactionCount: block.n_tx || block.tx.length,
        size: block.size,
        weight: block.weight
      });

      // Rate limiting
      if (i < limit - 1) {
        await new Promise(resolve => setTimeout(resolve, 100));
      }
    }

    res.json({
      success: true,
      data: {
        latestBlock: currentHeight,
        blocksRetrieved: history.length,
        history
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// Route 3: Address transaction history
app.get('/address/:address/history', async (req, res) => {
  try {
    const { address } = req.params;
    const limit = parseInt(req.query.limit) || 50;

    const details = await api.getAddressDetails(address, limit);

    const history = details.txs.map(tx => {
      let netChange = 0;

      // Calculate net change for this address
      tx.inputs.forEach(input => {
        if (input.prev_out && input.prev_out.addr === address) {
          netChange -= input.prev_out.value;
        }
      });

      tx.out.forEach(output => {
        if (output.addr === address) {
          netChange += output.value;
        }
      });

      return {
        hash: tx.hash,
        time: new Date(tx.time * 1000).toISOString(),
        netChangeSatoshis: netChange,
        netChangeBTC: api.satoshisToBTC(netChange),
        netChangeFormatted: api.formatBTC(api.satoshisToBTC(netChange)),
        size: tx.size,
        fee: tx.fee
      };
    });

    res.json({
      success: true,
      data: {
        address,
        totalTransactions: details.n_tx,
        totalReceived: api.formatBTC(api.satoshisToBTC(details.total_received)),
        totalSent: api.formatBTC(api.satoshisToBTC(details.total_sent)),
        finalBalance: api.formatBTC(api.satoshisToBTC(details.final_balance)),
        history
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// Route 4: Find all past whale transactions for an address
app.get('/address/:address/whale-transactions', async (req, res) => {
  try {
    const { address } = req.params;
    const minBTC = parseFloat(req.query.minBTC) || 100;
    const limit = parseInt(req.query.limit) || 100;

    const details = await api.getAddressDetails(address, limit);
    const minSatoshis = minBTC * 100000000;

    const whaleTransactions = details.txs.filter(tx => {
      let totalValue = 0;
      tx.out.forEach(output => {
        totalValue += output.value;
      });
      return totalValue >= minSatoshis;
    }).map(tx => {
      let totalValue = 0;
      let netChange = 0;

      tx.out.forEach(output => {
        totalValue += output.value;
        if (output.addr === address) {
          netChange += output.value;
        }
      });

      tx.inputs.forEach(input => {
        if (input.prev_out && input.prev_out.addr === address) {
          netChange -= input.prev_out.value;
        }
      });

      return {
        hash: tx.hash,
        time: new Date(tx.time * 1000).toISOString(),
        totalValue: api.formatBTC(api.satoshisToBTC(totalValue)),
        totalValueBTC: api.satoshisToBTC(totalValue),
        netChange: api.formatBTC(api.satoshisToBTC(netChange)),
        netChangeBTC: api.satoshisToBTC(netChange),
        direction: netChange > 0 ? 'received' : netChange < 0 ? 'sent' : 'neutral',
        inputs: tx.inputs.length,
        outputs: tx.out.length,
        topRecipients: tx.out
          .sort((a, b) => b.value - a.value)
          .slice(0, 3)
          .map(out => ({
            address: out.addr || 'Unknown',
            amount: api.formatBTC(api.satoshisToBTC(out.value))
          }))
      };
    });

    res.json({
      success: true,
      data: {
        address,
        minBTC,
        totalTransactionsScanned: details.txs.length,
        whaleTransactionsFound: whaleTransactions.length,
        whaleTransactions
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// Route 5: Balance progression over time
app.get('/address/:address/balance-progression', async (req, res) => {
  try {
    const { address } = req.params;
    const limit = parseInt(req.query.limit) || 50;

    const details = await api.getAddressDetails(address, limit);

    // Calculate balance at each transaction point
    let runningBalance = details.final_balance;
    const progression = [];

    // Process transactions from newest to oldest, working backwards
    for (let i = 0; i < details.txs.length; i++) {
      const tx = details.txs[i];

      // Add current state
      progression.unshift({
        time: new Date(tx.time * 1000).toISOString(),
        balanceSatoshis: runningBalance,
        balanceBTC: api.satoshisToBTC(runningBalance),
        balanceFormatted: api.formatBTC(api.satoshisToBTC(runningBalance)),
        transactionHash: tx.hash
      });

      // Calculate net change for this transaction
      let netChange = 0;

      tx.inputs.forEach(input => {
        if (input.prev_out && input.prev_out.addr === address) {
          netChange -= input.prev_out.value;
        }
      });

      tx.out.forEach(output => {
        if (output.addr === address) {
          netChange += output.value;
        }
      });

      // Work backwards: subtract the net change to get previous balance
      runningBalance -= netChange;
    }

    // Calculate monthly summary
    const monthlyData = groupTransactionsByMonth(details.txs);

    res.json({
      success: true,
      data: {
        address,
        currentBalance: api.formatBTC(api.satoshisToBTC(details.final_balance)),
        totalTransactions: details.n_tx,
        dataPoints: progression.length,
        progression,
        monthlyBreakdown: monthlyData.map(month => ({
          month: month.month,
          transactionCount: month.transactionCount,
          totalValueMoved: api.formatBTC(api.satoshisToBTC(month.totalValue))
        }))
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// Health check route
app.get('/health', (req, res) => {
  res.json({
    success: true,
    message: 'Blockchain API Server is running',
    timestamp: new Date().toISOString()
  });
});

// Root route with API documentation
app.get('/', (req, res) => {
  res.json({
    success: true,
    message: 'Blockchain.com Historical Data API',
    endpoints: {
      'GET /bitcoin/mom': 'Bitcoin Month-over-Month trend analysis',
      'GET /bitcoin/history?limit=10': 'Recent Bitcoin block history',
      'GET /address/:address/history?limit=50': 'Transaction history for an address',
      'GET /address/:address/whale-transactions?minBTC=100&limit=100': 'Find whale transactions for an address',
      'GET /address/:address/balance-progression?limit=50': 'Balance progression over time',
      'GET /health': 'Health check'
    },
    examples: {
      mom: 'http://localhost:3000/bitcoin/mom',
      history: 'http://localhost:3000/bitcoin/history?limit=5',
      addressHistory: 'http://localhost:3000/address/1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa/history?limit=10',
      whaleTransactions: 'http://localhost:3000/address/1P5ZEDWTKTFGxQjZphgWPQUpe554WKDfHQ/whale-transactions?minBTC=50',
      balanceProgression: 'http://localhost:3000/address/1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa/balance-progression?limit=20'
    }
  });
});

app.listen(PORT, () => {
  console.log(`🚀 Blockchain API Server running on http://localhost:${PORT}`);
  console.log(`\nAvailable endpoints:`);
  console.log(`  GET http://localhost:${PORT}/`);
  console.log(`  GET http://localhost:${PORT}/bitcoin/mom`);
  console.log(`  GET http://localhost:${PORT}/bitcoin/history`);
  console.log(`  GET http://localhost:${PORT}/address/:address/history`);
  console.log(`  GET http://localhost:${PORT}/address/:address/whale-transactions`);
  console.log(`  GET http://localhost:${PORT}/address/:address/balance-progression`);
  console.log(`\nTry: http://localhost:${PORT}/`);
});