Initial code commit.

backend/.gitignore

@@ -0,0 +1,42 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+
+# compiled output
+/dist
+/tmp
+
+# dependencies
+/node_modules
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# misc
+/.sass-cache
+/connect.lock
+/coverage/*
+/libpeerconnection.log
+npm-debug.log
+testem.log
+/typings
+
+# e2e
+/e2e/*.js
+/e2e/*.map
+
+#System Files
+.DS_Store
+Thumbs.db
+
+cache.json

backend/mempool-config.json

@@ -0,0 +1,22 @@
+{
+  "ENV": "dev",
+  "DB_HOST": "localhost",
+  "DB_PORT": 8889,
+  "DB_USER": "",
+  "DB_PASSWORD": "",
+  "DB_DATABASE": "",
+  "HTTP_PORT": 3000,
+  "API_ENDPOINT": "/api/v1/",
+  "CHAT_SSL_ENABLED": false,
+  "CHAT_SSL_PRIVKEY": "",
+  "CHAT_SSL_CERT": "",
+  "CHAT_SSL_CHAIN": "",
+  "MEMPOOL_REFRESH_RATE_MS": 500,
+  "INITIAL_BLOCK_AMOUNT": 8,
+  "KEEP_BLOCK_AMOUNT": 24,
+  "BITCOIN_NODE_HOST": "localhost",
+  "BITCOIN_NODE_PORT": 18332,
+  "BITCOIN_NODE_USER": "",
+  "BITCOIN_NODE_PASS": "",
+  "TX_PER_SECOND_SPAN_SECONDS": 150
+}

backend/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "mempool-backend",
+  "version": "1.0.0",
+  "description": "Bitcoin mempool visualizer",
+  "main": "index.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "bitcoin": "^3.0.1",
+    "compression": "^1.7.3",
+    "express": "^4.16.3",
+    "mysql2": "^1.6.1",
+    "request": "^2.88.0",
+    "ws": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.16.0",
+    "@types/mysql2": "github:types/mysql2",
+    "@types/request": "^2.48.2",
+    "@types/ws": "^6.0.1",
+    "tslint": "^5.11.0",
+    "typescript": "^3.1.1"
+  }
+}

backend/src/api/bitcoin-api-wrapper.ts

@@ -0,0 +1,84 @@
+const config = require('../../mempool-config.json');
+import * as bitcoin from 'bitcoin';
+import { ITransaction, IMempoolInfo, IBlock } from '../interfaces';
+
+class BitcoinApi {
+  client: any;
+
+  constructor() {
+    this.client = new bitcoin.Client({
+      host: config.BITCOIN_NODE_HOST,
+      port: config.BITCOIN_NODE_PORT,
+      user: config.BITCOIN_NODE_USER,
+      pass: config.BITCOIN_NODE_PASS,
+    });
+  }
+
+  getMempoolInfo(): Promise<IMempoolInfo> {
+    return new Promise((resolve, reject) => {
+      this.client.getMempoolInfo((err: Error, mempoolInfo: any) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(mempoolInfo);
+      });
+    });
+  }
+
+  getRawMempool(): Promise<ITransaction['txid'][]> {
+    return new Promise((resolve, reject) => {
+      this.client.getRawMemPool((err: Error, transactions: ITransaction['txid'][]) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(transactions);
+      });
+    });
+  }
+
+  getRawTransaction(txId: string): Promise<ITransaction> {
+    return new Promise((resolve, reject) => {
+      this.client.getRawTransaction(txId, true, (err: Error, txData: ITransaction) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(txData);
+      });
+    });
+  }
+
+  getBlockCount(): Promise<number> {
+    return new Promise((resolve, reject) => {
+      this.client.getBlockCount((err: Error, response: number) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(response);
+      });
+    });
+  }
+
+  getBlock(hash: string, verbosity:  1 | 2 = 1): Promise<IBlock> {
+    return new Promise((resolve, reject) => {
+      this.client.getBlock(hash, verbosity, (err: Error, block: IBlock) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(block);
+      });
+    });
+  }
+
+  getBlockHash(height: number): Promise<string> {
+    return new Promise((resolve, reject) => {
+      this.client.getBlockHash(height, (err: Error, response: string) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(response);
+      });
+    });
+  }
+}
+
+export default new BitcoinApi();

backend/src/api/blocks.ts

@@ -0,0 +1,197 @@
+const config = require('../../mempool-config.json');
+import bitcoinApi from './bitcoin-api-wrapper';
+import { DB } from '../database';
+import { IBlock, ITransaction } from '../interfaces';
+import memPool from './mempool';
+
+class Blocks {
+  private blocks: IBlock[] = [];
+  private newBlockCallback: Function | undefined;
+
+  public setNewBlockCallback(fn: Function) {
+    this.newBlockCallback = fn;
+  }
+
+  public getBlocks(): IBlock[] {
+    return this.blocks;
+  }
+
+  public formatBlock(block: IBlock) {
+    return {
+      hash: block.hash,
+      height: block.height,
+      nTx: block.nTx - 1,
+      size: block.size,
+      time: block.time,
+      weight: block.weight,
+      fees: block.fees,
+      minFee: block.minFee,
+      maxFee: block.maxFee,
+      medianFee: block.medianFee,
+    };
+  }
+
+  public async updateBlocks() {
+    try {
+      const blockCount = await bitcoinApi.getBlockCount();
+
+      let currentBlockHeight = 0;
+      if (this.blocks.length === 0) {
+        currentBlockHeight = blockCount - config.INITIAL_BLOCK_AMOUNT;
+      } else {
+        currentBlockHeight = this.blocks[this.blocks.length - 1].height;
+      }
+
+      while (currentBlockHeight < blockCount) {
+        currentBlockHeight++;
+
+        let block: IBlock | undefined;
+
+        const storedBlock = await this.$getBlockFromDatabase(currentBlockHeight);
+        if (storedBlock) {
+          block = storedBlock;
+        } else {
+          const blockHash = await bitcoinApi.getBlockHash(currentBlockHeight);
+          block = await bitcoinApi.getBlock(blockHash, 1);
+
+          const coinbase = await memPool.getRawTransaction(block.tx[0], true);
+          if (coinbase && coinbase.totalOut) {
+            block.fees = coinbase.totalOut;
+          }
+
+          const mempool = memPool.getMempool();
+          let found = 0;
+          let notFound = 0;
+
+          let transactions: ITransaction[] = [];
+
+          for (let i = 1; i < block.tx.length; i++) {
+            if (mempool[block.tx[i]]) {
+              transactions.push(mempool[block.tx[i]]);
+              found++;
+            } else {
+              const tx = await memPool.getRawTransaction(block.tx[i]);
+              if (tx) {
+                transactions.push(tx);
+              }
+              notFound++;
+            }
+          }
+
+          transactions.sort((a, b) => b.feePerVsize - a.feePerVsize);
+          transactions = transactions.filter((tx: ITransaction) => tx.feePerVsize);
+
+          block.minFee = transactions[transactions.length - 1] ? transactions[transactions.length - 1].feePerVsize : 0;
+          block.maxFee = transactions[0] ? transactions[0].feePerVsize : 0;
+          block.medianFee = this.median(transactions.map((tx) => tx.feePerVsize));
+
+          if (this.newBlockCallback) {
+            this.newBlockCallback(block);
+          }
+
+          await this.$saveBlockToDatabase(block);
+          await this.$saveTransactionsToDatabase(block.height, transactions);
+          console.log(`New block found (#${currentBlockHeight})! ${found} of ${block.tx.length} found in mempool. ${notFound} not found.`);
+        }
+
+        this.blocks.push(block);
+        if (this.blocks.length > config.KEEP_BLOCK_AMOUNT) {
+          this.blocks.shift();
+        }
+
+      }
+    } catch (err) {
+      console.log('Error getBlockCount', err);
+    }
+  }
+
+  private async $getBlockFromDatabase(height: number): Promise<IBlock | undefined> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = `
+        SELECT * FROM blocks WHERE height = ?
+      `;
+
+      const [rows] = await connection.query<any>(query, [height]);
+      connection.release();
+
+      if (rows[0]) {
+        return rows[0];
+      }
+    } catch (e) {
+      console.log('$get() block error', e);
+    }
+  }
+
+  private async $saveBlockToDatabase(block: IBlock) {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = `
+        INSERT IGNORE INTO blocks
+        (height, hash, size, weight, minFee, maxFee, time, fees, nTx, medianFee)
+        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `;
+
+      const params: (any)[] = [
+        block.height,
+        block.hash,
+        block.size,
+        block.weight,
+        block.minFee,
+        block.maxFee,
+        block.time,
+        block.fees,
+        block.nTx - 1,
+        block.medianFee,
+      ];
+
+      await connection.query(query, params);
+      connection.release();
+    } catch (e) {
+      console.log('$create() block error', e);
+    }
+  }
+
+  private async $saveTransactionsToDatabase(blockheight: number, transactions: ITransaction[]) {
+    try {
+      const connection = await DB.pool.getConnection();
+
+      for (let i = 0; i < transactions.length; i++) {
+        const query = `
+          INSERT IGNORE INTO transactions
+          (blockheight, txid, fee, feePerVsize)
+          VALUES(?, ?, ?, ?)
+        `;
+
+        const params: (any)[] = [
+          blockheight,
+          transactions[i].txid,
+          transactions[i].fee,
+          transactions[i].feePerVsize,
+        ];
+
+        await connection.query(query, params);
+      }
+
+
+      connection.release();
+    } catch (e) {
+      console.log('$create() transaction error', e);
+    }
+  }
+
+  private median(numbers: number[]) {
+    if (!numbers.length) { return 0; }
+    let medianNr = 0;
+    const numsLen = numbers.length;
+    numbers.sort();
+    if (numsLen % 2 === 0) {
+        medianNr = (numbers[numsLen / 2 - 1] + numbers[numsLen / 2]) / 2;
+    } else {
+        medianNr = numbers[(numsLen - 1) / 2];
+    }
+    return medianNr;
+  }
+}
+
+export default new Blocks();

backend/src/api/disk-cache.ts

@@ -0,0 +1,16 @@
+import * as fs from 'fs';
+
+class DiskCache {
+  static FILE_NAME = './cache.json';
+  constructor() { }
+
+  saveData(dataBlob: string) {
+    fs.writeFileSync(DiskCache.FILE_NAME, dataBlob, 'utf8');
+  }
+
+  loadData(): string {
+    return fs.readFileSync(DiskCache.FILE_NAME, 'utf8');
+  }
+}
+
+export default new DiskCache();

backend/src/api/fee-api.ts

@@ -0,0 +1,47 @@
+import projectedBlocks from './projected-blocks';
+import { DB } from '../database';
+
+class FeeApi {
+  constructor() { }
+
+  public getRecommendedFee() {
+    const pBlocks = projectedBlocks.getProjectedBlocks();
+    if (!pBlocks.length) {
+      return {
+        'fastestFee': 0,
+        'halfHourFee': 0,
+        'hourFee': 0,
+      };
+    }
+    let firstMedianFee = Math.ceil(pBlocks[0].medianFee);
+
+    if (pBlocks.length === 1 && pBlocks[0].blockWeight <= 2000000) {
+      firstMedianFee = 1;
+    }
+
+    const secondMedianFee = pBlocks[1] ? Math.ceil(pBlocks[1].medianFee) : firstMedianFee;
+    const thirdMedianFee = pBlocks[2] ? Math.ceil(pBlocks[2].medianFee) : secondMedianFee;
+
+    return {
+      'fastestFee': firstMedianFee,
+      'halfHourFee': secondMedianFee,
+      'hourFee': thirdMedianFee,
+    };
+  }
+
+  public async $getTransactionsForBlock(blockHeight: number): Promise<any[]> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = `SELECT feePerVsize AS fpv FROM transactions WHERE blockheight = ? ORDER BY feePerVsize ASC`;
+      const [rows] = await connection.query<any>(query, [blockHeight]);
+      connection.release();
+      return rows;
+    } catch (e) {
+      console.log('$getTransactionsForBlock() error', e);
+      return [];
+    }
+  }
+
+}
+
+export default new FeeApi();

backend/src/api/fiat-conversion.ts

@@ -0,0 +1,31 @@
+import * as request from 'request';
+
+class FiatConversion {
+  private tickers = {
+    'BTCUSD': {
+      'USD': 4110.78
+    },
+  };
+
+  constructor() { }
+
+  public startService() {
+    setInterval(this.updateCurrency.bind(this), 1000 * 60 * 60);
+    this.updateCurrency();
+  }
+
+  public getTickers() {
+    return this.tickers;
+  }
+
+  private updateCurrency() {
+    request('https://api.opennode.co/v1/rates', { json: true }, (err, res, body) => {
+      if (err) { return console.log(err); }
+      if (body && body.data) {
+        this.tickers = body.data;
+      }
+    });
+  }
+}
+
+export default new FiatConversion();

backend/src/api/mempool.ts

@@ -0,0 +1,156 @@
+const config = require('../../mempool-config.json');
+import bitcoinApi from './bitcoin-api-wrapper';
+import { ITransaction, IMempoolInfo, IMempool } from '../interfaces';
+
+class Mempool {
+  private mempool: IMempool = {};
+  private mempoolInfo: IMempoolInfo | undefined;
+  private mempoolChangedCallback: Function | undefined;
+
+  private txPerSecondArray: number[] = [];
+  private txPerSecond: number = 0;
+
+  private vBytesPerSecondArray: any[] = [];
+  private vBytesPerSecond: number = 0;
+
+  constructor() {
+    setInterval(this.updateTxPerSecond.bind(this), 1000);
+  }
+
+  public setMempoolChangedCallback(fn: Function) {
+    this.mempoolChangedCallback = fn;
+  }
+
+  public getMempool(): { [txid: string]: ITransaction } {
+    return this.mempool;
+  }
+
+  public setMempool(mempoolData: any) {
+    this.mempool = mempoolData;
+  }
+
+  public getMempoolInfo(): IMempoolInfo | undefined {
+    return this.mempoolInfo;
+  }
+
+  public getTxPerSecond(): number {
+    return this.txPerSecond;
+  }
+
+  public getVBytesPerSecond(): number {
+    return this.vBytesPerSecond;
+  }
+
+  public async getMemPoolInfo() {
+    try {
+      this.mempoolInfo = await bitcoinApi.getMempoolInfo();
+    } catch (err) {
+      console.log('Error getMempoolInfo', err);
+    }
+  }
+
+  public async getRawTransaction(txId: string, isCoinbase = false): Promise<ITransaction | false> {
+    try {
+      const transaction = await bitcoinApi.getRawTransaction(txId);
+      let totalIn = 0;
+      if (!isCoinbase) {
+        for (let i = 0; i < transaction.vin.length; i++) {
+          try {
+            const result = await bitcoinApi.getRawTransaction(transaction.vin[i].txid);
+            transaction.vin[i]['value'] = result.vout[transaction.vin[i].vout].value;
+            totalIn += result.vout[transaction.vin[i].vout].value;
+          } catch (err) {
+            console.log('Locating historical tx error');
+          }
+        }
+      }
+      let totalOut = 0;
+      transaction.vout.forEach((output) => totalOut += output.value);
+
+      if (totalIn > totalOut) {
+        transaction.fee = parseFloat((totalIn - totalOut).toFixed(8));
+        transaction.feePerWeightUnit = (transaction.fee * 100000000) / (transaction.vsize * 4) || 0;
+        transaction.feePerVsize = (transaction.fee * 100000000) / (transaction.vsize) || 0;
+      } else if (!isCoinbase) {
+        transaction.fee = 0;
+        transaction.feePerVsize = 0;
+        transaction.feePerWeightUnit = 0;
+        console.log('Minus fee error!');
+      }
+      transaction.totalOut = totalOut;
+      return transaction;
+    } catch (e) {
+      console.log(txId + ' not found');
+      return false;
+    }
+  }
+
+  public async updateMempool() {
+    console.log('Updating mempool');
+    const start = new Date().getTime();
+    let hasChange: boolean = false;
+    let txCount = 0;
+    try {
+      const transactions = await bitcoinApi.getRawMempool();
+      const diff = transactions.length - Object.keys(this.mempool).length;
+      for (const tx of transactions) {
+        if (!this.mempool[tx]) {
+          const transaction = await this.getRawTransaction(tx);
+          if (transaction) {
+            this.mempool[tx] = transaction;
+            txCount++;
+            this.txPerSecondArray.push(new Date().getTime());
+            this.vBytesPerSecondArray.push({
+              unixTime: new Date().getTime(),
+              vSize: transaction.vsize,
+            });
+            hasChange = true;
+            if (diff > 0) {
+              console.log('Calculated fee for transaction ' + txCount + ' / ' + diff);
+            } else {
+              console.log('Calculated fee for transaction ' + txCount);
+            }
+          } else {
+            console.log('Error finding transaction in mempool.');
+          }
+        }
+      }
+
+      const newMempool: IMempool = {};
+      transactions.forEach((tx) => {
+        if (this.mempool[tx]) {
+          newMempool[tx] = this.mempool[tx];
+        } else {
+          hasChange = true;
+        }
+      });
+
+      this.mempool = newMempool;
+
+      if (hasChange && this.mempoolChangedCallback) {
+        this.mempoolChangedCallback(this.mempool);
+      }
+
+      const end = new Date().getTime();
+      const time = end - start;
+      console.log('Mempool updated in ' + time / 1000 + ' seconds');
+    } catch (err) {
+      console.log('getRawMempool error.', err);
+    }
+  }
+
+  private updateTxPerSecond() {
+    const nowMinusTimeSpan = new Date().getTime() - (1000 * config.TX_PER_SECOND_SPAN_SECONDS);
+    this.txPerSecondArray = this.txPerSecondArray.filter((unixTime) => unixTime > nowMinusTimeSpan);
+    this.txPerSecond = this.txPerSecondArray.length / config.TX_PER_SECOND_SPAN_SECONDS || 0;
+
+    this.vBytesPerSecondArray = this.vBytesPerSecondArray.filter((data) => data.unixTime > nowMinusTimeSpan);
+    if (this.vBytesPerSecondArray.length) {
+      this.vBytesPerSecond = Math.round(
+        this.vBytesPerSecondArray.map((data) => data.vSize).reduce((a, b) => a + b) / config.TX_PER_SECOND_SPAN_SECONDS
+      );
+    }
+  }
+}
+
+export default new Mempool();

backend/src/api/projected-blocks.ts

@@ -0,0 +1,104 @@
+import { ITransaction, IProjectedBlock, IMempool, IProjectedBlockInternal } from '../interfaces';
+
+class ProjectedBlocks {
+  private projectedBlocks: IProjectedBlockInternal[] = [];
+
+  constructor() {}
+
+  public getProjectedBlocks(txId?: string): IProjectedBlock[] {
+    return this.projectedBlocks.map((projectedBlock) => {
+      return {
+        blockSize: projectedBlock.blockSize,
+        blockWeight: projectedBlock.blockWeight,
+        nTx: projectedBlock.nTx,
+        minFee: projectedBlock.minFee,
+        maxFee: projectedBlock.maxFee,
+        minWeightFee: projectedBlock.minWeightFee,
+        maxWeightFee: projectedBlock.maxWeightFee,
+        medianFee: projectedBlock.medianFee,
+        fees: projectedBlock.fees,
+        hasMytx: txId ? projectedBlock.txIds.some((tx) => tx === txId) : false
+      };
+    });
+  }
+
+  public getProjectedBlockFeesForBlock(index: number) {
+    const projectedBlock = this.projectedBlocks[index];
+
+    if (!projectedBlock) {
+      throw new Error('No projected block for that index');
+    }
+
+    return projectedBlock.txFeePerVsizes.map((fpv) => {
+      return {'fpv': fpv};
+    });
+  }
+
+  public updateProjectedBlocks(memPool: IMempool): void {
+    const latestMempool = memPool;
+    const memPoolArray: ITransaction[] = [];
+    for (const i in latestMempool) {
+      if (latestMempool.hasOwnProperty(i)) {
+        memPoolArray.push(latestMempool[i]);
+      }
+    }
+
+    if (!memPoolArray.length) {
+      this.projectedBlocks = [];
+    }
+
+    memPoolArray.sort((a, b) => b.feePerWeightUnit - a.feePerWeightUnit);
+    const memPoolArrayFiltered = memPoolArray.filter((tx) => tx.feePerWeightUnit);
+    const projectedBlocks: any = [];
+
+    let blockWeight = 0;
+    let blockSize = 0;
+    let transactions: ITransaction[] = [];
+    memPoolArrayFiltered.forEach((tx) => {
+      if (blockWeight + tx.vsize * 4 < 4000000 || projectedBlocks.length === 3) {
+        blockWeight += tx.vsize * 4;
+        blockSize += tx.size;
+        transactions.push(tx);
+      } else {
+        projectedBlocks.push(this.dataToProjectedBlock(transactions, blockSize, blockWeight));
+        blockWeight = 0;
+        blockSize = 0;
+        transactions = [];
+      }
+    });
+    if (transactions.length) {
+      projectedBlocks.push(this.dataToProjectedBlock(transactions, blockSize, blockWeight));
+    }
+    this.projectedBlocks = projectedBlocks;
+  }
+
+  private dataToProjectedBlock(transactions: ITransaction[], blockSize: number, blockWeight: number): IProjectedBlockInternal {
+    return {
+      blockSize: blockSize,
+      blockWeight: blockWeight,
+      nTx: transactions.length - 1,
+      minFee: transactions[transactions.length - 1].feePerVsize,
+      maxFee: transactions[0].feePerVsize,
+      minWeightFee: transactions[transactions.length - 1].feePerWeightUnit,
+      maxWeightFee: transactions[0].feePerWeightUnit,
+      medianFee: this.median(transactions.map((tx) => tx.feePerVsize)),
+      txIds: transactions.map((tx) => tx.txid),
+      txFeePerVsizes: transactions.map((tx) => tx.feePerVsize).reverse(),
+      fees: transactions.map((tx) => tx.fee).reduce((acc, currValue) => acc + currValue),
+    };
+  }
+
+  private median(numbers: number[]) {
+    let medianNr = 0;
+    const numsLen = numbers.length;
+    numbers.sort();
+    if (numsLen % 2 === 0) {
+        medianNr = (numbers[numsLen / 2 - 1] + numbers[numsLen / 2]) / 2;
+    } else {
+        medianNr = numbers[(numsLen - 1) / 2];
+    }
+    return medianNr;
+  }
+}
+
+export default new ProjectedBlocks();

backend/src/api/statistics.ts

@@ -0,0 +1,379 @@
+import memPool from './mempool';
+import { DB } from '../database';
+
+import { ITransaction, IMempoolStats } from '../interfaces';
+
+class Statistics {
+  protected intervalTimer: NodeJS.Timer | undefined;
+
+  constructor() {
+  }
+
+  public startStatistics(): void {
+    const now = new Date();
+    const nextInterval = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours(),
+      Math.floor(now.getMinutes() / 1) * 1 + 1, 0, 0);
+    const difference = nextInterval.getTime() - now.getTime();
+
+    setTimeout(() => {
+      this.runStatistics();
+      this.intervalTimer = setInterval(() => { this.runStatistics(); }, 1 * 60 * 1000);
+    }, difference);
+  }
+
+  private runStatistics(): void {
+    const currentMempool = memPool.getMempool();
+    const txPerSecond = memPool.getTxPerSecond();
+    const vBytesPerSecond = memPool.getVBytesPerSecond();
+
+    if (txPerSecond === 0) {
+      return;
+    }
+
+    console.log('Running statistics');
+
+    let memPoolArray: ITransaction[] = [];
+    for (const i in currentMempool) {
+      if (currentMempool.hasOwnProperty(i)) {
+        memPoolArray.push(currentMempool[i]);
+      }
+    }
+    // Remove 0 and undefined
+    memPoolArray = memPoolArray.filter((tx) => tx.feePerWeightUnit);
+
+    if (!memPoolArray.length) {
+      return;
+    }
+
+    memPoolArray.sort((a, b) => a.feePerWeightUnit - b.feePerWeightUnit);
+    const totalWeight = memPoolArray.map((tx) => tx.vsize).reduce((acc, curr) => acc + curr) * 4;
+    const totalFee = memPoolArray.map((tx) => tx.fee).reduce((acc, curr) => acc + curr);
+
+    const logFees = [1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 30, 40, 50, 60, 70, 80, 90, 100, 125, 150, 175, 200,
+      250, 300, 350, 400, 500, 600, 700, 800, 900, 1000, 1200, 1400, 1600, 1800, 2000];
+
+    const weightUnitFees: { [feePerWU: number]: number } = {};
+    const weightVsizeFees: { [feePerWU: number]: number } = {};
+
+    memPoolArray.forEach((transaction) => {
+      for (let i = 0; i < logFees.length; i++) {
+        if ((logFees[i] === 2000 && transaction.feePerWeightUnit >= 2000) || transaction.feePerWeightUnit <= logFees[i]) {
+          if (weightUnitFees[logFees[i]]) {
+            weightUnitFees[logFees[i]] += transaction.vsize * 4;
+          } else {
+            weightUnitFees[logFees[i]] = transaction.vsize * 4;
+          }
+          break;
+        }
+      }
+    });
+
+    memPoolArray.forEach((transaction) => {
+      for (let i = 0; i < logFees.length; i++) {
+        if ((logFees[i] === 2000 && transaction.feePerVsize >= 2000) || transaction.feePerVsize <= logFees[i]) {
+          if (weightVsizeFees[logFees[i]]) {
+            weightVsizeFees[logFees[i]] += transaction.vsize;
+          } else {
+            weightVsizeFees[logFees[i]] = transaction.vsize;
+          }
+          break;
+        }
+      }
+    });
+
+    this.$create({
+      added: 'NOW()',
+      unconfirmed_transactions: memPoolArray.length,
+      tx_per_second: txPerSecond,
+      vbytes_per_second: Math.round(vBytesPerSecond),
+      mempool_byte_weight: totalWeight,
+      total_fee: totalFee,
+      fee_data: JSON.stringify({
+        'wu': weightUnitFees,
+        'vsize': weightVsizeFees
+      }),
+      vsize_1: weightVsizeFees['1'] || 0,
+      vsize_2: weightVsizeFees['2'] || 0,
+      vsize_3: weightVsizeFees['3'] || 0,
+      vsize_4: weightVsizeFees['4'] || 0,
+      vsize_5: weightVsizeFees['5'] || 0,
+      vsize_6: weightVsizeFees['6'] || 0,
+      vsize_8: weightVsizeFees['8'] || 0,
+      vsize_10: weightVsizeFees['10'] || 0,
+      vsize_12: weightVsizeFees['12'] || 0,
+      vsize_15: weightVsizeFees['15'] || 0,
+      vsize_20: weightVsizeFees['20'] || 0,
+      vsize_30: weightVsizeFees['30'] || 0,
+      vsize_40: weightVsizeFees['40'] || 0,
+      vsize_50: weightVsizeFees['50'] || 0,
+      vsize_60: weightVsizeFees['60'] || 0,
+      vsize_70: weightVsizeFees['70'] || 0,
+      vsize_80: weightVsizeFees['80'] || 0,
+      vsize_90: weightVsizeFees['90'] || 0,
+      vsize_100: weightVsizeFees['100'] || 0,
+      vsize_125: weightVsizeFees['125'] || 0,
+      vsize_150: weightVsizeFees['150'] || 0,
+      vsize_175: weightVsizeFees['175'] || 0,
+      vsize_200: weightVsizeFees['200'] || 0,
+      vsize_250: weightVsizeFees['250'] || 0,
+      vsize_300: weightVsizeFees['300'] || 0,
+      vsize_350: weightVsizeFees['350'] || 0,
+      vsize_400: weightVsizeFees['400'] || 0,
+      vsize_500: weightVsizeFees['500'] || 0,
+      vsize_600: weightVsizeFees['600'] || 0,
+      vsize_700: weightVsizeFees['700'] || 0,
+      vsize_800: weightVsizeFees['800'] || 0,
+      vsize_900: weightVsizeFees['900'] || 0,
+      vsize_1000: weightVsizeFees['1000'] || 0,
+      vsize_1200: weightVsizeFees['1200'] || 0,
+      vsize_1400: weightVsizeFees['1400'] || 0,
+      vsize_1600: weightVsizeFees['1600'] || 0,
+      vsize_1800: weightVsizeFees['1800'] || 0,
+      vsize_2000: weightVsizeFees['2000'] || 0,
+    });
+  }
+
+  private async $create(statistics: IMempoolStats): Promise<void> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = `INSERT INTO statistics(
+              added,
+              unconfirmed_transactions,
+              tx_per_second,
+              vbytes_per_second,
+              mempool_byte_weight,
+              fee_data,
+              total_fee,
+              vsize_1,
+              vsize_2,
+              vsize_3,
+              vsize_4,
+              vsize_5,
+              vsize_6,
+              vsize_8,
+              vsize_10,
+              vsize_12,
+              vsize_15,
+              vsize_20,
+              vsize_30,
+              vsize_40,
+              vsize_50,
+              vsize_60,
+              vsize_70,
+              vsize_80,
+              vsize_90,
+              vsize_100,
+              vsize_125,
+              vsize_150,
+              vsize_175,
+              vsize_200,
+              vsize_250,
+              vsize_300,
+              vsize_350,
+              vsize_400,
+              vsize_500,
+              vsize_600,
+              vsize_700,
+              vsize_800,
+              vsize_900,
+              vsize_1000,
+              vsize_1200,
+              vsize_1400,
+              vsize_1600,
+              vsize_1800,
+              vsize_2000
+            )
+            VALUES (${statistics.added}, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+               ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+
+      const params: (string | number)[] = [
+        statistics.unconfirmed_transactions,
+        statistics.tx_per_second,
+        statistics.vbytes_per_second,
+        statistics.mempool_byte_weight,
+        statistics.fee_data,
+        statistics.total_fee,
+        statistics.vsize_1,
+        statistics.vsize_2,
+        statistics.vsize_3,
+        statistics.vsize_4,
+        statistics.vsize_5,
+        statistics.vsize_6,
+        statistics.vsize_8,
+        statistics.vsize_10,
+        statistics.vsize_12,
+        statistics.vsize_15,
+        statistics.vsize_20,
+        statistics.vsize_30,
+        statistics.vsize_40,
+        statistics.vsize_50,
+        statistics.vsize_60,
+        statistics.vsize_70,
+        statistics.vsize_80,
+        statistics.vsize_90,
+        statistics.vsize_100,
+        statistics.vsize_125,
+        statistics.vsize_150,
+        statistics.vsize_175,
+        statistics.vsize_200,
+        statistics.vsize_250,
+        statistics.vsize_300,
+        statistics.vsize_350,
+        statistics.vsize_400,
+        statistics.vsize_500,
+        statistics.vsize_600,
+        statistics.vsize_700,
+        statistics.vsize_800,
+        statistics.vsize_900,
+        statistics.vsize_1000,
+        statistics.vsize_1200,
+        statistics.vsize_1400,
+        statistics.vsize_1600,
+        statistics.vsize_1800,
+        statistics.vsize_2000,
+      ];
+      await connection.query(query, params);
+      connection.release();
+    } catch (e) {
+      console.log('$create() error', e);
+    }
+  }
+
+  public async $listLatestFromId(fromId: number): Promise<IMempoolStats[]> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = `SELECT * FROM statistics WHERE id > ? ORDER BY id DESC`;
+      const [rows] = await connection.query<any>(query, [fromId]);
+      connection.release();
+      return rows;
+    } catch (e) {
+      console.log('$listLatestFromId() error', e);
+      return [];
+    }
+  }
+
+  private getQueryForDays(days: number, groupBy: number) {
+
+    return `SELECT id, added, unconfirmed_transactions,
+            AVG(tx_per_second) AS tx_per_second,
+            AVG(vbytes_per_second) AS vbytes_per_second,
+            AVG(vsize_1) AS vsize_1,
+            AVG(vsize_2) AS vsize_2,
+            AVG(vsize_3) AS vsize_3,
+            AVG(vsize_4) AS vsize_4,
+            AVG(vsize_5) AS vsize_5,
+            AVG(vsize_6) AS vsize_6,
+            AVG(vsize_8) AS vsize_8,
+            AVG(vsize_10) AS vsize_10,
+            AVG(vsize_12) AS vsize_12,
+            AVG(vsize_15) AS vsize_15,
+            AVG(vsize_20) AS vsize_20,
+            AVG(vsize_30) AS vsize_30,
+            AVG(vsize_40) AS vsize_40,
+            AVG(vsize_50) AS vsize_50,
+            AVG(vsize_60) AS vsize_60,
+            AVG(vsize_70) AS vsize_70,
+            AVG(vsize_80) AS vsize_80,
+            AVG(vsize_90) AS vsize_90,
+            AVG(vsize_100) AS vsize_100,
+            AVG(vsize_125) AS vsize_125,
+            AVG(vsize_150) AS vsize_150,
+            AVG(vsize_175) AS vsize_175,
+            AVG(vsize_200) AS vsize_200,
+            AVG(vsize_250) AS vsize_250,
+            AVG(vsize_300) AS vsize_300,
+            AVG(vsize_350) AS vsize_350,
+            AVG(vsize_400) AS vsize_400,
+            AVG(vsize_500) AS vsize_500,
+            AVG(vsize_600) AS vsize_600,
+            AVG(vsize_700) AS vsize_700,
+            AVG(vsize_800) AS vsize_800,
+            AVG(vsize_900) AS vsize_900,
+            AVG(vsize_1000) AS vsize_1000,
+            AVG(vsize_1200) AS vsize_1200,
+            AVG(vsize_1400) AS vsize_1400,
+            AVG(vsize_1600) AS vsize_1600,
+            AVG(vsize_1800) AS vsize_1800,
+            AVG(vsize_2000) AS vsize_2000 FROM statistics GROUP BY UNIX_TIMESTAMP(added) DIV ${groupBy} ORDER BY id DESC LIMIT ${days}`;
+  }
+
+  public async $list2H(): Promise<IMempoolStats[]> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = `SELECT * FROM statistics ORDER BY id DESC LIMIT 120`;
+      const [rows] = await connection.query<any>(query);
+      connection.release();
+      return rows;
+    } catch (e) {
+      console.log('$list2H() error', e);
+      return [];
+    }
+  }
+
+  public async $list24H(): Promise<IMempoolStats[]> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = this.getQueryForDays(120, 720);
+      const [rows] = await connection.query<any>(query);
+      connection.release();
+      return rows;
+    } catch (e) {
+      return [];
+    }
+  }
+
+  public async $list1W(): Promise<IMempoolStats[]> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = this.getQueryForDays(120, 5040);
+      const [rows] = await connection.query<any>(query);
+      connection.release();
+      return rows;
+    } catch (e) {
+      console.log('$list1W() error', e);
+      return [];
+    }
+  }
+
+  public async $list1M(): Promise<IMempoolStats[]> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = this.getQueryForDays(120, 20160);
+      const [rows] = await connection.query<any>(query);
+      connection.release();
+      return rows;
+    } catch (e) {
+      console.log('$list1M() error', e);
+      return [];
+    }
+  }
+
+  public async $list3M(): Promise<IMempoolStats[]> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = this.getQueryForDays(120, 60480);
+      const [rows] = await connection.query<any>(query);
+      connection.release();
+      return rows;
+    } catch (e) {
+      console.log('$list3M() error', e);
+      return [];
+    }
+  }
+
+  public async $list6M(): Promise<IMempoolStats[]> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = this.getQueryForDays(120, 120960);
+      const [rows] = await connection.query<any>(query);
+      connection.release();
+      return rows;
+    } catch (e) {
+      console.log('$list6M() error', e);
+      return [];
+    }
+  }
+
+}
+
+export default new Statistics();

backend/src/database.ts

@@ -0,0 +1,26 @@
+const config = require('../mempool-config.json');
+import { createPool } from 'mysql2/promise';
+
+export class DB {
+  static pool = createPool({
+    host: config.DB_HOST,
+    port: config.DB_PORT,
+    database: config.DB_DATABASE,
+    user: config.DB_USER,
+    password: config.DB_PASSWORD,
+    connectionLimit: 10,
+    supportBigNumbers: true,
+  });
+}
+
+export async function checkDbConnection() {
+  try {
+    const connection = await DB.pool.getConnection();
+    console.log('MySQL connection established.');
+    connection.release();
+  } catch (e) {
+    console.log('Could not connect to MySQL.');
+    console.log(e);
+    process.exit(1);
+  }
+}

backend/src/index.ts

@@ -0,0 +1,231 @@
+const config = require('../mempool-config.json');
+import * as fs from 'fs';
+import * as express from 'express';
+import * as compression from 'compression';
+import * as http from 'http';
+import * as https from 'https';
+import * as WebSocket from 'ws';
+
+import bitcoinApi from './api/bitcoin-api-wrapper';
+import diskCache from './api/disk-cache';
+import memPool from './api/mempool';
+import blocks from './api/blocks';
+import projectedBlocks from './api/projected-blocks';
+import statistics from './api/statistics';
+import { IBlock, IMempool } from './interfaces';
+
+import routes from './routes';
+import fiatConversion from './api/fiat-conversion';
+
+class MempoolSpace {
+  private wss: WebSocket.Server;
+  private server: https.Server | http.Server;
+  private app: any;
+
+  constructor() {
+    this.app = express();
+    this.app
+      .use((req, res, next)  => {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        next();
+      })
+      .use(compression());
+    if (config.ENV === 'dev') {
+      this.server = http.createServer(this.app);
+      this.wss = new WebSocket.Server({ server: this.server });
+    } else {
+      const credentials = {
+        cert: fs.readFileSync('/etc/letsencrypt/live/mempool.space/fullchain.pem'),
+        key: fs.readFileSync('/etc/letsencrypt/live/mempool.space/privkey.pem'),
+      };
+      this.server = https.createServer(credentials, this.app);
+      this.wss = new WebSocket.Server({ server: this.server });
+    }
+
+    this.setUpRoutes();
+    this.setUpWebsocketHandling();
+    this.setUpMempoolCache();
+    this.runMempoolIntervalFunctions();
+
+    statistics.startStatistics();
+    fiatConversion.startService();
+
+    this.server.listen(8999, () => {
+      console.log(`Server started on port 8999 :)`);
+    });
+  }
+
+  private async runMempoolIntervalFunctions() {
+    await blocks.updateBlocks();
+    await memPool.getMemPoolInfo();
+    await memPool.updateMempool();
+    setTimeout(this.runMempoolIntervalFunctions.bind(this), config.MEMPOOL_REFRESH_RATE_MS);
+  }
+
+  private setUpMempoolCache() {
+    const cacheData = diskCache.loadData();
+    if (cacheData) {
+      memPool.setMempool(JSON.parse(cacheData));
+    }
+
+    process.on('SIGINT', (options) => {
+      console.log('SIGINT');
+      diskCache.saveData(JSON.stringify(memPool.getMempool()));
+      process.exit(2);
+    });
+  }
+
+  private setUpWebsocketHandling() {
+    this.wss.on('connection', (client: WebSocket) => {
+      let theBlocks = blocks.getBlocks();
+      theBlocks = theBlocks.concat([]).splice(theBlocks.length - config.INITIAL_BLOCK_AMOUNT);
+
+      const formatedBlocks = theBlocks.map((b) => blocks.formatBlock(b));
+
+      client.send(JSON.stringify({
+        'mempoolInfo': memPool.getMempoolInfo(),
+        'blocks': formatedBlocks,
+        'projectedBlocks': projectedBlocks.getProjectedBlocks(),
+        'txPerSecond': memPool.getTxPerSecond(),
+        'vBytesPerSecond': memPool.getVBytesPerSecond(),
+        'conversions': fiatConversion.getTickers()['BTCUSD'],
+      }));
+
+      client.on('message', async (message: any) => {
+        try {
+          const parsedMessage = JSON.parse(message);
+          if (parsedMessage.action === 'track-tx' && parsedMessage.txId && /^[a-fA-F0-9]{64}$/.test(parsedMessage.txId)) {
+            const tx = await memPool.getRawTransaction(parsedMessage.txId);
+            if (tx) {
+              console.log('Now tracking: ' + parsedMessage.txId);
+              client['trackingTx'] = true;
+              client['txId'] = parsedMessage.txId;
+              client['tx'] = tx;
+
+              if (tx.blockhash) {
+                const currentBlocks = blocks.getBlocks();
+                const foundBlock = currentBlocks.find((block) => block.tx && block.tx.some((i: string) => i === parsedMessage.txId));
+                if (foundBlock) {
+                  console.log('Found block by looking in local cache');
+                  client['blockHeight'] = foundBlock.height;
+                } else {
+                  const theBlock = await bitcoinApi.getBlock(tx.blockhash);
+                  if (theBlock) {
+                    client['blockHeight'] = theBlock.height;
+                  }
+                }
+              } else {
+                client['blockHeight'] = 0;
+              }
+              client.send(JSON.stringify({
+                'projectedBlocks': projectedBlocks.getProjectedBlocks(client['txId']),
+                'track-tx': {
+                  tracking: true,
+                  blockHeight: client['blockHeight'],
+                  tx: client['tx'],
+                }
+              }));
+            } else {
+              console.log('TX NOT FOUND, NOT TRACKING');
+              client.send(JSON.stringify({
+                'track-tx': {
+                  tracking: false,
+                  blockHeight: 0,
+                  message: 'not-found',
+                }
+              }));
+            }
+          }
+          if (parsedMessage.action === 'stop-tracking-tx') {
+            console.log('STOP TRACKING');
+            client['trackingTx'] = false;
+            client.send(JSON.stringify({
+              'track-tx': {
+                tracking: false,
+                blockHeight: 0,
+                message: 'not-found',
+              }
+            }));
+          }
+        } catch (e) {
+          console.log(e);
+        }
+      });
+
+      client.on('close', () => {
+        client['trackingTx'] = false;
+      });
+    });
+
+    blocks.setNewBlockCallback((block: IBlock) => {
+      const formattedBlocks = blocks.formatBlock(block);
+
+      this.wss.clients.forEach((client) => {
+        if (client.readyState !== WebSocket.OPEN) {
+          return;
+        }
+
+        if (client['trackingTx'] === true && client['blockHeight'] === 0) {
+          if (block.tx.some((tx) => tx === client['txId'])) {
+            client['blockHeight'] = block.height;
+          }
+        }
+
+        client.send(JSON.stringify({
+          'block': formattedBlocks,
+          'track-tx': {
+            tracking: client['trackingTx'] || false,
+            blockHeight: client['blockHeight'],
+          }
+        }));
+      });
+    });
+
+    memPool.setMempoolChangedCallback((newMempool: IMempool) => {
+      projectedBlocks.updateProjectedBlocks(newMempool);
+
+      let pBlocks = projectedBlocks.getProjectedBlocks();
+      const mempoolInfo = memPool.getMempoolInfo();
+      const txPerSecond = memPool.getTxPerSecond();
+      const vBytesPerSecond = memPool.getVBytesPerSecond();
+
+      this.wss.clients.forEach((client: WebSocket) => {
+        if (client.readyState !== WebSocket.OPEN) {
+          return;
+        }
+
+        if (client['trackingTx'] && client['blockHeight'] === 0) {
+          pBlocks = projectedBlocks.getProjectedBlocks(client['txId']);
+        }
+
+        client.send(JSON.stringify({
+          'projectedBlocks': pBlocks,
+          'mempoolInfo': mempoolInfo,
+          'txPerSecond': txPerSecond,
+          'vBytesPerSecond': vBytesPerSecond,
+          'track-tx': {
+            tracking: client['trackingTx'] || false,
+            blockHeight: client['blockHeight'],
+          }
+        }));
+      });
+    });
+  }
+
+  private setUpRoutes() {
+    this.app
+      .get(config.API_ENDPOINT + 'transactions/height/:id', routes.$getgetTransactionsForBlock)
+      .get(config.API_ENDPOINT + 'transactions/projected/:id', routes.getgetTransactionsForProjectedBlock)
+      .get(config.API_ENDPOINT + 'fees/recommended', routes.getRecommendedFees)
+      .get(config.API_ENDPOINT + 'statistics/live', routes.getLiveResult)
+      .get(config.API_ENDPOINT + 'statistics/2h', routes.get2HStatistics)
+      .get(config.API_ENDPOINT + 'statistics/24h', routes.get24HStatistics)
+      .get(config.API_ENDPOINT + 'statistics/1w', routes.get1WHStatistics)
+      .get(config.API_ENDPOINT + 'statistics/1m', routes.get1MStatistics)
+      .get(config.API_ENDPOINT + 'statistics/3m', routes.get3MStatistics)
+      .get(config.API_ENDPOINT + 'statistics/6m', routes.get6MStatistics)
+      ;
+  }
+}
+
+const mempoolSpace = new MempoolSpace();

backend/src/interfaces.ts

@@ -0,0 +1,151 @@
+export interface IMempoolInfo {
+  size: number;
+  bytes: number;
+  usage: number;
+  maxmempool: number;
+  mempoolminfee: number;
+  minrelaytxfee: number;
+}
+
+export interface ITransaction {
+  txid: string;
+  hash: string;
+  version: number;
+  size: number;
+  vsize: number;
+  locktime: number;
+  vin: Vin[];
+  vout: Vout[];
+  hex: string;
+  fee: number;
+  feePerWeightUnit: number;
+  feePerVsize: number;
+  blockhash?: string;
+  confirmations?: number;
+  time?: number;
+  blocktime?: number;
+  totalOut?: number;
+}
+
+export interface IBlock {
+  hash: string;
+  confirmations: number;
+  strippedsize: number;
+  size: number;
+  weight: number;
+  height: number;
+  version: number;
+  versionHex: string;
+  merkleroot: string;
+  tx: any;
+  time: number;
+  mediantime: number;
+  nonce: number;
+  bits: string;
+  difficulty: number;
+  chainwork: string;
+  nTx: number;
+  previousblockhash: string;
+  fees: number;
+
+  minFee?: number;
+  maxFee?: number;
+  medianFee?: number;
+}
+
+interface ScriptSig {
+  asm: string;
+  hex: string;
+}
+
+interface Vin {
+  txid: string;
+  vout: number;
+  scriptSig: ScriptSig;
+  sequence: number;
+}
+
+interface ScriptPubKey {
+  asm: string;
+  hex: string;
+  reqSigs: number;
+  type: string;
+  addresses: string[];
+}
+
+interface Vout {
+  value: number;
+  n: number;
+  scriptPubKey: ScriptPubKey;
+}
+
+export interface IMempoolStats {
+  id?: number;
+  added: string;
+  unconfirmed_transactions: number;
+  tx_per_second: number;
+  vbytes_per_second: number;
+  total_fee: number;
+  mempool_byte_weight: number;
+  fee_data: string;
+
+  vsize_1: number;
+  vsize_2: number;
+  vsize_3: number;
+  vsize_4: number;
+  vsize_5: number;
+  vsize_6: number;
+  vsize_8: number;
+  vsize_10: number;
+  vsize_12: number;
+  vsize_15: number;
+  vsize_20: number;
+  vsize_30: number;
+  vsize_40: number;
+  vsize_50: number;
+  vsize_60: number;
+  vsize_70: number;
+  vsize_80: number;
+  vsize_90: number;
+  vsize_100: number;
+  vsize_125: number;
+  vsize_150: number;
+  vsize_175: number;
+  vsize_200: number;
+  vsize_250: number;
+  vsize_300: number;
+  vsize_350: number;
+  vsize_400: number;
+  vsize_500: number;
+  vsize_600: number;
+  vsize_700: number;
+  vsize_800: number;
+  vsize_900: number;
+  vsize_1000: number;
+  vsize_1200: number;
+  vsize_1400: number;
+  vsize_1600: number;
+  vsize_1800: number;
+  vsize_2000: number;
+}
+
+export interface IProjectedBlockInternal extends IProjectedBlock {
+  txIds: string[];
+  txFeePerVsizes: number[];
+}
+
+export interface IProjectedBlock {
+  blockSize: number;
+  blockWeight: number;
+  maxFee: number;
+  maxWeightFee: number;
+  medianFee: number;
+  minFee: number;
+  minWeightFee: number;
+  nTx: number;
+  fees: number;
+  hasMyTxId?: boolean;
+}
+
+export interface IMempool { [txid: string]: ITransaction; }
+

backend/src/routes.ts

@@ -0,0 +1,63 @@
+import statistics from './api/statistics';
+import feeApi from './api/fee-api';
+import projectedBlocks from './api/projected-blocks';
+
+class Routes {
+  constructor() {}
+
+  public async getLiveResult(req, res) {
+    const result = await statistics.$listLatestFromId(req.query.lastId);
+    res.send(result);
+  }
+
+  public async get2HStatistics(req, res) {
+    const result = await statistics.$list2H();
+    res.send(result);
+  }
+
+  public async get24HStatistics(req, res) {
+    const result = await statistics.$list24H();
+    res.send(result);
+  }
+
+  public async get1WHStatistics(req, res) {
+    const result = await statistics.$list1W();
+    res.send(result);
+  }
+
+  public async get1MStatistics(req, res) {
+    const result = await statistics.$list1M();
+    res.send(result);
+  }
+
+  public async get3MStatistics(req, res) {
+    const result = await statistics.$list3M();
+    res.send(result);
+  }
+
+  public async get6MStatistics(req, res) {
+    const result = await statistics.$list6M();
+    res.send(result);
+  }
+
+  public async getRecommendedFees(req, res) {
+    const result = feeApi.getRecommendedFee();
+    res.send(result);
+  }
+
+  public async $getgetTransactionsForBlock(req, res) {
+    const result = await feeApi.$getTransactionsForBlock(req.params.id);
+    res.send(result);
+  }
+
+  public async getgetTransactionsForProjectedBlock(req, res) {
+    try {
+      const result = await projectedBlocks.getProjectedBlockFeesForBlock(req.params.id);
+      res.send(result);
+    } catch (e) {
+      res.status(500).send(e.message);
+    }
+  }
+}
+
+export default new Routes();

backend/tsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es2015",
+        "strict": true,
+        "noImplicitAny": false,
+        "sourceMap": false,
+        "outDir": "dist",
+        "moduleResolution": "node",
+        "typeRoots": [
+            "node_modules/@types"
+        ]
+    },
+    "include": [
+        "src/**/*.ts",
+    ],
+    "exclude": [
+        "dist/**"
+    ]
+}

backend/tslint.json

@@ -0,0 +1,137 @@
+{
+  "rules": {
+    "arrow-return-shorthand": true,
+    "callable-types": true,
+    "class-name": true,
+    "comment-format": [
+      true,
+      "check-space"
+    ],
+    "curly": true,
+    "deprecation": {
+      "severity": "warn"
+    },
+    "eofline": true,
+    "forin": true,
+    "import-blacklist": [
+      true,
+      "rxjs",
+      "rxjs/Rx"
+    ],
+    "import-spacing": true,
+    "indent": [
+      true,
+      "spaces"
+    ],
+    "interface-over-type-literal": true,
+    "label-position": true,
+    "max-line-length": [
+      true,
+      140
+    ],
+    "member-access": false,
+    "member-ordering": [
+      true,
+      {
+        "order": [
+          "static-field",
+          "instance-field",
+          "static-method",
+          "instance-method"
+        ]
+      }
+    ],
+    "no-arg": true,
+    "no-bitwise": true,
+    "no-console": [
+      true,
+      "debug",
+      "info",
+      "time",
+      "timeEnd",
+      "trace"
+    ],
+    "no-construct": true,
+    "no-debugger": true,
+    "no-duplicate-super": true,
+    "no-empty": false,
+    "no-empty-interface": true,
+    "no-eval": true,
+    "no-inferrable-types": false,
+    "no-misused-new": true,
+    "no-non-null-assertion": true,
+    "no-shadowed-variable": true,
+    "no-string-literal": false,
+    "no-string-throw": true,
+    "no-switch-case-fall-through": true,
+    "no-trailing-whitespace": true,
+    "no-unnecessary-initializer": true,
+    "no-unused-expression": true,
+    "no-use-before-declare": true,
+    "no-var-keyword": true,
+    "object-literal-sort-keys": false,
+    "one-line": [
+      true,
+      "check-open-brace",
+      "check-catch",
+      "check-else",
+      "check-whitespace"
+    ],
+    "prefer-const": true,
+    "quotemark": [
+      true,
+      "single"
+    ],
+    "radix": true,
+    "semicolon": [
+      true,
+      "always"
+    ],
+    "triple-equals": [
+      true,
+      "allow-null-check"
+    ],
+    "typedef-whitespace": [
+      true,
+      {
+        "call-signature": "nospace",
+        "index-signature": "nospace",
+        "parameter": "nospace",
+        "property-declaration": "nospace",
+        "variable-declaration": "nospace"
+      }
+    ],
+    "unified-signatures": true,
+    "variable-name": false,
+    "whitespace": [
+      true,
+      "check-branch",
+      "check-decl",
+      "check-operator",
+      "check-separator",
+      "check-type"
+    ],
+    "directive-selector": [
+      true,
+      "attribute",
+      "app",
+      "camelCase"
+    ],
+    "component-selector": [
+      true,
+      "element",
+      "app",
+      "kebab-case"
+    ],
+    "no-output-on-prefix": true,
+    "use-input-property-decorator": true,
+    "use-output-property-decorator": true,
+    "use-host-property-decorator": true,
+    "no-input-rename": true,
+    "no-output-rename": true,
+    "use-life-cycle-interface": true,
+    "use-pipe-transform-interface": true,
+    "component-class-suffix": true,
+    "directive-class-suffix": true
+  }
+}