Bump version number to v2.1.2

Updating mempool logo and adding new mempool space logo.

.gitattributes

@@ -0,0 +1,3 @@
+# ignore all differences in line endings
+package.json eol=crlf -crlf
+*/package.json eol=crlf -crlf

.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: ['mempool'] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: ['https://mempool.space/about'] # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,37 @@
+<!--
+   SUPPORT REQUESTS: This is for reporting bugs in Mempool.
+   If you have a support request, please join our Keybase group:
+   https://keybase.io/team/mempool
+-->
+
+### Description
+
+<!-- brief description of the bug -->
+
+#### Version
+
+<!-- commit id or version number -->
+
+### Steps to reproduce
+
+<!--if you can reliably reproduce the bug, list the steps here  -->
+
+### Expected behaviour
+
+<!--description of the expected behavior -->
+
+### Actual behaviour
+
+<!-- explain what happened instead of the expected behaviour -->
+
+### Screenshots
+
+<!--Screenshots if gui related, drag and drop to add to the issue -->
+
+#### Device or machine
+
+<!-- device/machine used, operating system -->
+
+#### Additional info
+
+<!-- Additional information useful for debugging (e.g. logs) -->

.github/workflows/on-tag.yml

@@ -0,0 +1,77 @@
+name: Docker build on tag
+env:
+  DOCKER_CLI_EXPERIMENTAL: enabled
+  TAG_FMT: '^refs/tags/(((.?[0-9]+){3,4}))$'
+  DOCKER_BUILDKIT: 0
+  COMPOSE_DOCKER_CLI_BUILD: 0
+
+on:
+  push:
+    tags:
+      - v[0-9]+.[0-9]+.[0-9]+
+      - v[0-9]+.[0-9]+.[0-9]+-*
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        service:
+          - frontend
+          - backend
+    runs-on: ubuntu-18.04
+    name: Build and push to DockerHub
+    steps:
+      - name: Set env variables
+        run: echo "TAG=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_ENV
+
+      - name: Show set environment variables
+        run: |
+          printf "      TAG: %s\n"  "$TAG"
+
+      - name: Login to Docker for building
+        run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin
+
+      - name: Checkout project
+        uses: actions/checkout@v2
+
+      - name: Init repo for Dockerization
+        run: docker/init.sh "$TAG"
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+        id: qemu
+
+      - name: Setup Docker buildx action
+        uses: docker/setup-buildx-action@v1
+        id: buildx
+
+      - name: Available platforms
+        run: echo ${{ steps.buildx.outputs.platforms }}
+
+      - name: Cache Docker layers
+        uses: actions/cache@v2
+        id: cache
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-buildx-
+
+      - name: Run Docker buildx for ${{ matrix.service }} against tag
+        run: |
+          docker buildx build \
+          --cache-from "type=local,src=/tmp/.buildx-cache" \
+          --cache-to "type=local,dest=/tmp/.buildx-cache" \
+          --platform linux/amd64,linux/arm64,linux/arm/v7 \
+          --tag ${{ secrets.DOCKER_HUB_USER }}/${{ matrix.service }}:$TAG \
+          --output "type=registry" ./${{ matrix.service }}/
+
+      - name: Run Docker buildx for ${{ matrix.service }} against latest
+        run: |
+          docker buildx build \
+          --cache-from "type=local,src=/tmp/.buildx-cache" \
+          --cache-to "type=local,dest=/tmp/.buildx-cache" \
+          --platform linux/amd64,linux/arm64,linux/arm/v7 \
+          --tag ${{ secrets.DOCKER_HUB_USER }}/${{ matrix.service }}:latest \
+          --output "type=registry" ./${{ matrix.service }}/
+

.gitignore

@@ -0,0 +1 @@
+sitemap

Dockerfile

@@ -1,57 +0,0 @@
-FROM alpine:latest
-
-RUN mkdir /mempool.space/
-COPY ./backend /mempool.space/backend/
-COPY ./frontend /mempool.space/frontend/
-COPY ./mariadb-structure.sql /mempool.space/mariadb-structure.sql
-
-RUN apk add mariadb mariadb-client git nginx npm rsync bash
-
-RUN mysql_install_db --user=mysql --datadir=/var/lib/mysql/
-RUN /usr/bin/mysqld_safe --datadir='/var/lib/mysql/'& \
-    sleep 60 && \
-    mysql -e "create database mempool" && \
-    mysql -e "grant all privileges on mempool.* to 'mempool'@'localhost' identified by 'mempool'" && \
-    mysql mempool < /mempool.space/mariadb-structure.sql
-RUN sed -i "/^skip-networking/ c#skip-networking" /etc/my.cnf.d/mariadb-server.cnf
-
-RUN export NG_CLI_ANALYTICS=ci && \
-    npm install -g typescript && \
-    cd /mempool.space/frontend && \
-    npm install && \
-    cd /mempool.space/backend && \
-    npm install && \
-    tsc
-
-COPY ./nginx-nossl-docker.conf /etc/nginx/nginx.conf
-    
-ENV ENV dev
-ENV DB_HOST localhost
-ENV DB_PORT 3306
-ENV DB_USER mempool
-ENV DB_PASSWORD mempool
-ENV DB_DATABASE mempool
-ENV API_ENDPOINT /api/v1/
-ENV CHAT_SSL_ENABLED false
-ENV MEMPOOL_REFRESH_RATE_MS 500
-ENV INITIAL_BLOCK_AMOUNT 8
-ENV DEFAULT_PROJECTED_BLOCKS_AMOUNT 3
-ENV KEEP_BLOCK_AMOUNT 24
-ENV BITCOIN_NODE_HOST bitcoinhost
-ENV BITCOIN_NODE_PORT 8332
-ENV BITCOIN_NODE_USER bitcoinuser
-ENV BITCOIN_NODE_PASS bitcoinpass
-ENV TX_PER_SECOND_SPAN_SECONDS 150
-ENV BACKEND_API bitcoind
-ENV ELECTRS_API_URL https://mempool.space/api
-
-RUN cd /mempool.space/frontend/ && \
-    npm run build && \
-    rsync -av --delete dist/mempool/ /var/www/html/
-
-EXPOSE 80
-
-COPY ./entrypoint.sh /mempool.space/entrypoint.sh
-RUN chmod +x /mempool.space/entrypoint.sh
-WORKDIR /mempool.space
-CMD ["/mempool.space/entrypoint.sh"]

LICENSE

@@ -1,11 +1,11 @@
-MIT License
+MIT License with Commons Clause License Condition v1.0
 
-Copyright (c) 2019 Simon Lindh
+Copyright (c) 2019-2020 The Mempool Open Source Project
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+to use, copy, modify, merge, publish, distribute, and/or sublicense
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
@@ -19,3 +19,17 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+Commons Clause License Condition v1.0
+
+Without limiting other conditions in the License, the grant of rights under
+the License will not include, and the License does not grant to you, the
+right to Sell the Software.
+
+For purposes of the foregoing, “Sell” means practicing any or all of the
+rights granted to you under the License to provide to third parties, for a
+fee or other consideration (including without limitation fees for hosting or
+consulting/ support services related to the Software), a product or service
+whose value derives, entirely or substantially, from the functionality of
+the Software. Any license notice or attribution required by the License must
+also include this Commons Cause License Condition notice.

README.md

@@ -1,92 +1,53 @@
-# mempool
-## a mempool visualizer and explorer for Bitcoin
+# The Mempool Open Source Project
 
-![mempool](https://pbs.twimg.com/media/EAETXWCU4AAv2v-?format=jpg&name=4096x4096)
-![blockchain](https://pbs.twimg.com/media/EAETXWAU8AAj4IP?format=jpg&name=4096x4096)
+Mempool is the fully featured visualizer, explorer, and API service running on [mempool.space](https://mempool.space/), an open source project developed and operated for the benefit of the Bitcoin community, with a focus on the emerging transaction fee market to help our transition into a multi-layer ecosystem.
 
-## Pick the right version for your use case
+![mempool](https://mempool.space/resources/screenshots/v2.1.0-dashboard.png)
 
-Mempool V1 has basic explorer functionality and can run from a Bitcoin Core full node on a Raspberry Pi (no pruning, txindex=1).
+## Installation Methods
 
-Mempool V2 is what runs on https://mempool.space and has advanced explorer functionality, but requires a fully synced electrs backend running on powerful server hardware.
+Mempool can be self-hosted on a wide variety of your own hardware, ranging from a simple one-click installation on a Raspberry Pi distro, all the way to an advanced high availability cluster of powerful servers for a production instance. We support the following installation methods, ranked in order from simple to advanced:
 
-# Mempool V1 using Docker (easy)
+1) One-click installation on: [Umbrel](https://github.com/getumbrel/umbrel), [RaspiBlitz](https://github.com/rootzoll/raspiblitz), [RoninDojo](https://code.samourai.io/ronindojo/RoninDojo), or [MyNode](https://github.com/mynodebtc/mynode).
+2) [Docker installation on Linux using docker-compose](https://github.com/mempool/mempool/tree/master/docker)
+3) [Manual installation on Linux or FreeBSD](https://github.com/mempool/mempool#manual-installation)
+4) [Production installation on a powerful FreeBSD server](https://github.com/mempool/mempool/tree/master/production)
+5) [High Availability cluster using powerful FreeBSD servers](https://github.com/mempool/mempool/tree/master/production#high-availability)
 
-Install from Docker Hub, passing your Bitcoin Core RPC credentials as environment variables:
+# Manual Installation
 
-```bash
-docker pull mempool/mempool:v1.0
-docker create -p 80:80 -e BITCOIN_NODE_HOST=192.168.1.102 -e BITCOIN_NODE_USER=foo -e BITCOIN_NODE_PASS=bar --name mempool mempool/mempool:v1.0
-docker start mempool
-docker logs mempool
-```
-
-You should see mempool starting up, which takes over an hour (needs 8 blocks). When it's ready, visit http://127.0.0.1/ to see your mempool.
-
-# Mempool V1 not using Docker (advanced)
+The following instructions are for a manual installation on Linux or FreeBSD. The file and directory paths may need to be changed to match your OS.
 
 ## Dependencies
 
-* Bitcoin (full node required, no pruning, txindex=1)
+* Bitcoin Core (no pruning, txindex=1)
+* Electrum Server (romanz/electrs)
 * NodeJS (official stable LTS)
-* MySQL or MariaDB (default config)
-* Nginx (use supplied nginx.conf)
+* MariaDB (default config)
+* Nginx (use supplied nginx.conf and nginx-mempool.conf)
 
-## Checking out release tag
+## Mempool
+
+Clone the mempool repo, and checkout the latest release tag:
 ```bash
-  git clone https://github.com/mempool-space/mempool.space
-  cd mempool.space
-  git checkout v1.0.0 # put latest release tag here
+  git clone https://github.com/mempool/mempool
+  cd mempool
+  latestrelease=$(curl -s https://api.github.com/repos/mempool/mempool/releases/latest|grep tag_name|head -1|cut -d '"' -f4)
+  git checkout $latestrelease
 ```
 
 ## Bitcoin Core (bitcoind)
 
-Enable RPC and txindex in bitcoin.conf
-
+Enable RPC and txindex in `bitcoin.conf`:
 ```bash
   rpcuser=mempool
   rpcpassword=71b61986da5b03a5694d7c7d5165ece5
   txindex=1
 ```
 
-## NodeJS
-
-Install dependencies and build code:
-
-```bash
-  # Install TypeScript Globally
-  npm install -g typescript
-
-  # Frontend
-  cd frontend
-  npm install
-  npm run build
-
-  # Backend
-  cd ../backend/
-  npm install
-  npm run build
-```
-
-## Mempool Configuration
-In the `backend` folder, make a copy of the sample config and modify it to fit your settings.
-
-```bash
-  cp mempool-config.sample.json mempool-config.json
-```
-
-Edit `mempool-config.json` to add your Bitcoin Core node RPC credentials:
-```bash
-  "BITCOIN_NODE_HOST": "192.168.1.5",
-  "BITCOIN_NODE_PORT": 8332,
-  "BITCOIN_NODE_USER": "mempool",
-  "BITCOIN_NODE_PASS": "71b61986da5b03a5694d7c7d5165ece5",
-```
-
 ## MySQL
 
-Install MariaDB:
-
+Install MariaDB from OS package manager:
 ```bash
   # Linux
   apt-get install mariadb-server mariadb-client
@@ -104,51 +65,72 @@ Create database and grant privileges:
   MariaDB [(none)]> create database mempool;
   Query OK, 1 row affected (0.00 sec)
 
-  MariaDB [(none)]> grant all privileges on mempool.* to 'mempool' identified by 'mempool';
+  MariaDB [(none)]> grant all privileges on mempool.* to 'mempool'@'%' identified by 'mempool';
   Query OK, 0 rows affected (0.00 sec)
 ```
 
-From the root folder, initialize database structure:
-
+From the mempool repo's top-level folder, import the database structure:
 ```bash
   mysql -u mempool -p mempool < mariadb-structure.sql
 ```
 
-## Running (Backend)
-
-Create an initial empty cache and start the app:
+## Mempool Backend
+Install mempool dependencies from npm and build the backend:
 
 ```bash
-  touch cache.json
-  npm run start # node dist/index.js
+  # backend
+  cd ../backend/
+  npm install
+  npm run build
 ```
 
-After starting you should see:
+In the `backend` folder, make a copy of the sample config and modify it to fit your settings.
 
 ```bash
-  Server started on port 8999 :)
-  New block found (#586498)! 0 of 1986 found in mempool. 1985 not found.
-  New block found (#586499)! 0 of 1094 found in mempool. 1093 not found.
-  New block found (#586500)! 0 of 2735 found in mempool. 2734 not found.
-  New block found (#586501)! 0 of 2675 found in mempool. 2674 not found.
-  New block found (#586502)! 0 of 975 found in mempool. 974 not found.
-  New block found (#586503)! 0 of 2130 found in mempool. 2129 not found.
-  New block found (#586504)! 0 of 2770 found in mempool. 2769 not found.
-  New block found (#586505)! 0 of 2759 found in mempool. 2758 not found.
-  Updating mempool
-  Calculated fee for transaction 1 / 3257
-  Calculated fee for transaction 2 / 3257
-  Calculated fee for transaction 3 / 3257
-  Calculated fee for transaction 4 / 3257
-  Calculated fee for transaction 5 / 3257
-  Calculated fee for transaction 6 / 3257
-  Calculated fee for transaction 7 / 3257
-  Calculated fee for transaction 8 / 3257
-  Calculated fee for transaction 9 / 3257
+  cp mempool-config.sample.json mempool-config.json
 ```
-You need to wait for at least *8 blocks to be mined*, so please wait ~80 minutes.
-The backend also needs to index transactions, calculate fees, etc.
-When it's ready you will see output like this:
+
+Edit `mempool-config.json` to add your Bitcoin Core node RPC credentials:
+```bash
+{
+  "MEMPOOL": {
+    "NETWORK": "mainnet",
+    "BACKEND": "electrum",
+    "HTTP_PORT": 8999,
+    "API_URL_PREFIX": "/api/v1/",
+    "POLL_RATE_MS": 2000
+  },
+  "CORE_RPC": {
+    "USERNAME": "mempool",
+    "PASSWORD": "71b61986da5b03a5694d7c7d5165ece5"
+  },
+  "ELECTRUM": {
+    "HOST": "127.0.0.1",
+    "PORT": 50002,
+    "TLS_ENABLED": true,
+  },
+  "DATABASE": {
+    "ENABLED": true,
+    "HOST": "127.0.0.1",
+    "PORT": 3306,
+    "USERNAME": "mempool",
+    "PASSWORD": "mempool",
+    "DATABASE": "mempool"
+  },
+  "STATISTICS": {
+    "ENABLED": true,
+    "TX_PER_SECOND_SAMPLE_PERIOD": 150
+  }
+}
+```
+
+Start the backend:
+
+```bash
+  npm run start
+```
+
+When it's running you should see output like this:
 
 ```bash
   Mempool updated in 0.189 seconds
@@ -171,36 +153,38 @@ When it's ready you will see output like this:
   Updating mempool
 ```
 
-## nginx + CertBot (LetsEncrypt)
-Setup nginx using the supplied nginx.conf
+## Mempool Frontend
+
+Install mempool dependencies from npm and build the frontend static HTML/CSS/JS:
+
+```bash
+  # frontend
+  cd frontend
+  npm install
+  npm run build
+```
+
+Install the output into nginx webroot folder:
+
+```bash
+  sudo rsync -av --delete dist/mempool/ /var/www/html/
+```
+
+## nginx + certbot
+
+Install the supplied nginx.conf and nginx-mempool.conf in /etc/nginx
 
 ```bash
   # install nginx and certbot
   apt-get install -y nginx python-certbot-nginx
 
+  # install the mempool configuration for nginx
+  cp nginx.conf nginx-mempool.conf /etc/nginx/nginx.conf
+
   # replace example.com with your domain name
   certbot --nginx -d example.com
 
-  # install the mempool configuration for nginx
-  cp nginx.conf /etc/nginx/nginx.conf
-
-  # edit the installed nginx.conf, and replace all
-  # instances of example.com with your domain name
 ```
-Make sure you can access https://<your-domain-name>/ in browser before proceeding
-
-
-## Running (Frontend)
-
-Build the frontend static HTML/CSS/JS, rsync the output into nginx folder:
-
-```bash
-  cd frontend/
-  npm run build
-  sudo rsync -av --delete dist/mempool/ /var/www/html/
-```
-
-## Try It Out
 
 If everything went okay you should see the beautiful mempool :grin:
 

backend/.gitignore

@@ -41,5 +41,3 @@ testem.log
 #System Files
 .DS_Store
 Thumbs.db
-
-cache.json

backend/cache/.gitignore

@@ -0,0 +1 @@
+*.json

backend/mempool-config.sample.json

@@ -1,25 +1,53 @@
 {
-  "ENV": "dev",
-  "DB_HOST": "localhost",
-  "DB_PORT": 3306,
-  "DB_USER": "mempool",
-  "DB_PASSWORD": "mempool",
-  "DB_DATABASE": "mempool",
-  "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,
-  "DEFAULT_PROJECTED_BLOCKS_AMOUNT": 3,
-  "KEEP_BLOCK_AMOUNT": 24,
-  "BITCOIN_NODE_HOST": "localhost",
-  "BITCOIN_NODE_PORT": 8332,
-  "BITCOIN_NODE_USER": "",
-  "BITCOIN_NODE_PASS": "",
-  "BACKEND_API": "bitcoind",
-  "ELECTRS_API_URL": "https://mempool.space/api",
-  "TX_PER_SECOND_SPAN_SECONDS": 150
+  "MEMPOOL": {
+    "NETWORK": "mainnet",
+    "BACKEND": "electrum",
+    "HTTP_PORT": 8999,
+    "SPAWN_CLUSTER_PROCS": 0,
+    "API_URL_PREFIX": "/api/v1/",
+    "POLL_RATE_MS": 2000,
+    "CACHE_DIR": "./cache",
+    "CLEAR_PROTECTION_MINUTES": 20
+  },
+  "CORE_RPC": {
+    "HOST": "127.0.0.1",
+    "PORT": 8332,
+    "USERNAME": "mempool",
+    "PASSWORD": "mempool"
+  },
+  "ELECTRUM": {
+    "HOST": "127.0.0.1",
+    "PORT": 50002,
+    "TLS_ENABLED": true
+  },
+  "ESPLORA": {
+    "REST_API_URL": "http://127.0.0.1:3000"
+  },
+  "CORE_RPC_MINFEE": {
+    "ENABLED": false,
+    "HOST": "127.0.0.1",
+    "PORT": 8332,
+    "USERNAME": "mempool",
+    "PASSWORD": "mempool"
+  },
+  "DATABASE": {
+    "ENABLED": true,
+    "HOST": "127.0.0.1",
+    "PORT": 3306,
+    "DATABASE": "mempool",
+    "USERNAME": "mempool",
+    "PASSWORD": "mempool"
+  },
+  "STATISTICS": {
+    "ENABLED": true,
+    "TX_PER_SECOND_SAMPLE_PERIOD": 150
+  },
+  "BISQ_BLOCKS": {
+    "ENABLED": false,
+    "DATA_PATH": "/bisq/statsnode-data/btc_mainnet/db/json"
+  },
+  "BISQ_MARKETS": {
+    "ENABLED": false,
+    "DATA_PATH": "/bisq/statsnode-data/btc_mainnet/db"
+  }
 }

backend/package.json

@@ -1,31 +1,50 @@
 {
   "name": "mempool-backend",
-  "version": "1.0.0",
-  "description": "Bitcoin Mempool Visualizer",
+  "version": "2.1.2",
+  "description": "Bitcoin mempool visualizer and blockchain explorer backend",
+  "license": "MIT",
+  "homepage": "https://mempool.space",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mempool/mempool"
+  },
+  "bugs": {
+    "url": "https://github.com/mempool/mempool/issues"
+  },
+  "keywords": [
+    "bitcoin",
+    "mempool",
+    "blockchain",
+    "explorer",
+    "liquid"
+  ],
   "main": "index.ts",
   "scripts": {
-    "build": "tsc",
-    "start": "npm run build && node dist/index.js"
+    "ng": "./node_modules/@angular/cli/bin/ng",
+    "tsc": "./node_modules/typescript/bin/tsc",
+    "build": "npm run tsc",
+    "start": "node --max-old-space-size=2048 dist/index.js",
+    "start-production": "node --max-old-space-size=4096 dist/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "author": {
-    "name": "Simon Lindh",
-    "url": "https://github.com/mempool-space/mempool.space"
-  },
-  "license": "MIT",
   "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"
+    "@mempool/bitcoin": "^3.0.2",
+    "@mempool/electrum-client": "^1.1.7",
+    "axios": "^0.21.1",
+    "bitcoinjs-lib": "^5.2.0",
+    "crypto-js": "^4.0.0",
+    "express": "^4.17.1",
+    "locutus": "^2.0.12",
+    "mysql2": "2.2.5",
+    "node-worker-threads-pool": "^1.4.2",
+    "ws": "^7.3.1"
   },
   "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"
+    "@types/compression": "^1.0.1",
+    "@types/express": "^4.17.2",
+    "@types/locutus": "^0.0.6",
+    "@types/ws": "^6.0.4",
+    "tslint": "~6.1.0",
+    "typescript": "~3.9.7"
   }
 }

backend/src/api/backend-info.ts

@@ -0,0 +1,34 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import logger from '../logger';
+
+class BackendInfo {
+  gitCommitHash = '';
+  hostname = '';
+
+  constructor() {
+    this.setLatestCommitHash();
+    this.hostname = os.hostname();
+  }
+
+  public getBackendInfo() {
+    return {
+      'hostname': this.hostname,
+      'git-commit': this.gitCommitHash,
+    };
+  }
+
+  public getShortCommitHash() {
+    return this.gitCommitHash.slice(0, 7);
+  }
+
+  private setLatestCommitHash(): void {
+    try {
+      this.gitCommitHash = fs.readFileSync('../.git/refs/heads/master').toString().trim();
+    } catch (e) {
+      logger.err('Could not load git commit info: ' + e.message || e);
+    }
+  }
+}
+
+export default new BackendInfo();

backend/src/api/bisq/bisq.ts

@@ -0,0 +1,275 @@
+import config from '../../config';
+import * as fs from 'fs';
+import axios from 'axios';
+import { BisqBlocks, BisqBlock, BisqTransaction, BisqStats, BisqTrade } from './interfaces';
+import { Common } from '../common';
+import { BlockExtended } from '../../mempool.interfaces';
+import { StaticPool } from 'node-worker-threads-pool';
+import logger from '../../logger';
+
+class Bisq {
+  private static BLOCKS_JSON_FILE_PATH = config.BISQ_BLOCKS.DATA_PATH + '/all/blocks.json';
+  private latestBlockHeight = 0;
+  private blocks: BisqBlock[] = [];
+  private transactions: BisqTransaction[] = [];
+  private transactionIndex: { [txId: string]: BisqTransaction } = {};
+  private blockIndex: { [hash: string]: BisqBlock } = {};
+  private addressIndex: { [address: string]: BisqTransaction[] } = {};
+  private stats: BisqStats = {
+    minted: 0,
+    burnt: 0,
+    addresses: 0,
+    unspent_txos: 0,
+    spent_txos: 0,
+  };
+  private price: number = 0;
+  private priceUpdateCallbackFunction: ((price: number) => void) | undefined;
+  private topDirectoryWatcher: fs.FSWatcher | undefined;
+  private subdirectoryWatcher: fs.FSWatcher | undefined;
+  private jsonParsePool = new StaticPool({
+    size: 4,
+    task: (blob: string) => JSON.parse(blob),
+  });
+
+  constructor() {}
+
+  startBisqService(): void {
+    this.checkForBisqDataFolder();
+    this.loadBisqDumpFile();
+    setInterval(this.updatePrice.bind(this), 1000 * 60 * 60);
+    this.updatePrice();
+    this.startTopDirectoryWatcher();
+    this.startSubDirectoryWatcher();
+  }
+
+  handleNewBitcoinBlock(block: BlockExtended): void {
+    if (block.height - 10 > this.latestBlockHeight && this.latestBlockHeight !== 0) {
+      logger.warn(`Bitcoin block height (#${block.height}) has diverged from the latest Bisq block height (#${this.latestBlockHeight}). Restarting watchers...`);
+      this.startTopDirectoryWatcher();
+      this.startSubDirectoryWatcher();
+    }
+  }
+
+  getTransaction(txId: string): BisqTransaction | undefined {
+    return this.transactionIndex[txId];
+  }
+
+  getTransactions(start: number, length: number, types: string[]): [BisqTransaction[], number] {
+    let transactions = this.transactions;
+    if (types.length) {
+      transactions = transactions.filter((tx) => types.indexOf(tx.txType) > -1);
+    }
+    return [transactions.slice(start, length + start), transactions.length];
+  }
+
+  getBlock(hash: string): BisqBlock | undefined {
+    return this.blockIndex[hash];
+  }
+
+  getAddress(hash: string): BisqTransaction[] {
+    return this.addressIndex[hash];
+  }
+
+  getBlocks(start: number, length: number): [BisqBlock[], number] {
+    return [this.blocks.slice(start, length + start), this.blocks.length];
+  }
+
+  getStats(): BisqStats {
+    return this.stats;
+  }
+
+  setPriceCallbackFunction(fn: (price: number) => void) {
+    this.priceUpdateCallbackFunction = fn;
+  }
+
+  getLatestBlockHeight(): number {
+    return this.latestBlockHeight;
+  }
+
+  private checkForBisqDataFolder() {
+    if (!fs.existsSync(Bisq.BLOCKS_JSON_FILE_PATH)) {
+      logger.warn(Bisq.BLOCKS_JSON_FILE_PATH + ` doesn't exist. Make sure Bisq is running and the config is correct before starting the server.`);
+      return process.exit(1);
+    }
+  }
+
+  private startTopDirectoryWatcher() {
+    if (this.topDirectoryWatcher) {
+      this.topDirectoryWatcher.close();
+    }
+    let fsWait: NodeJS.Timeout | null = null;
+    this.topDirectoryWatcher = fs.watch(config.BISQ_BLOCKS.DATA_PATH, () => {
+      if (fsWait) {
+        clearTimeout(fsWait);
+      }
+      if (this.subdirectoryWatcher) {
+        this.subdirectoryWatcher.close();
+      }
+      fsWait = setTimeout(() => {
+        logger.debug(`Bisq restart detected. Resetting both watchers in 3 minutes.`);
+        setTimeout(() => {
+          this.startTopDirectoryWatcher();
+          this.startSubDirectoryWatcher();
+          this.loadBisqDumpFile();
+        }, 180000);
+      }, 15000);
+    });
+  }
+
+  private startSubDirectoryWatcher() {
+    if (this.subdirectoryWatcher) {
+      this.subdirectoryWatcher.close();
+    }
+    if (!fs.existsSync(Bisq.BLOCKS_JSON_FILE_PATH)) {
+      logger.warn(Bisq.BLOCKS_JSON_FILE_PATH + ` doesn't exist. Trying to restart sub directory watcher again in 3 minutes.`);
+      setTimeout(() => this.startSubDirectoryWatcher(), 180000);
+      return;
+    }
+    let fsWait: NodeJS.Timeout | null = null;
+    this.subdirectoryWatcher = fs.watch(config.BISQ_BLOCKS.DATA_PATH + '/all', () => {
+      if (fsWait) {
+        clearTimeout(fsWait);
+      }
+      fsWait = setTimeout(() => {
+        logger.debug(`Change detected in the Bisq data folder.`);
+        this.loadBisqDumpFile();
+      }, 2000);
+    });
+  }
+
+  private updatePrice() {
+    axios.get<BisqTrade[]>('https://bisq.markets/api/trades/?market=bsq_btc', { timeout: 10000 })
+      .then((response) => {
+        const prices: number[] = [];
+        response.data.forEach((trade) => {
+          prices.push(parseFloat(trade.price) * 100000000);
+        });
+        prices.sort((a, b) => a - b);
+        this.price = Common.median(prices);
+        if (this.priceUpdateCallbackFunction) {
+          this.priceUpdateCallbackFunction(this.price);
+        }
+    }).catch((err) => {
+      logger.err('Error updating Bisq market price: ' + err);
+    });
+  }
+
+  private async loadBisqDumpFile(): Promise<void> {
+    try {
+      const data = await this.loadData();
+      await this.loadBisqBlocksDump(data);
+      this.buildIndex();
+      this.calculateStats();
+    } catch (e) {
+      logger.err('loadBisqDumpFile() error.' + e.message || e);
+    }
+  }
+
+  private buildIndex() {
+    const start = new Date().getTime();
+    this.transactions = [];
+    this.transactionIndex = {};
+    this.addressIndex = {};
+
+    this.blocks.forEach((block) => {
+      /* Build block index */
+      if (!this.blockIndex[block.hash]) {
+        this.blockIndex[block.hash] = block;
+      }
+
+      /* Build transactions index */
+      block.txs.forEach((tx) => {
+        this.transactions.push(tx);
+        this.transactionIndex[tx.id] = tx;
+      });
+    });
+
+    /* Build address index */
+    this.transactions.forEach((tx) => {
+      tx.inputs.forEach((input) => {
+        if (!this.addressIndex[input.address]) {
+          this.addressIndex[input.address] = [];
+        }
+        if (this.addressIndex[input.address].indexOf(tx) === -1) {
+          this.addressIndex[input.address].push(tx);
+        }
+      });
+      tx.outputs.forEach((output) => {
+        if (!this.addressIndex[output.address]) {
+          this.addressIndex[output.address] = [];
+        }
+        if (this.addressIndex[output.address].indexOf(tx) === -1) {
+          this.addressIndex[output.address].push(tx);
+        }
+      });
+    });
+
+    const time = new Date().getTime() - start;
+    logger.debug('Bisq data index rebuilt in ' + time + ' ms');
+  }
+
+  private calculateStats() {
+    let minted = 0;
+    let burned = 0;
+    let unspent = 0;
+    let spent = 0;
+
+    this.transactions.forEach((tx) => {
+      tx.outputs.forEach((output) => {
+        if (output.opReturn) {
+          return;
+        }
+        if (output.txOutputType === 'GENESIS_OUTPUT' || output.txOutputType === 'ISSUANCE_CANDIDATE_OUTPUT' && output.isVerified) {
+          minted += output.bsqAmount;
+        }
+        if (output.isUnspent) {
+          unspent++;
+        } else {
+          spent++;
+        }
+      });
+      burned += tx['burntFee'];
+    });
+
+    this.stats = {
+      addresses: Object.keys(this.addressIndex).length,
+      minted: minted / 100,
+      burnt: burned / 100,
+      spent_txos: spent,
+      unspent_txos: unspent,
+    };
+  }
+
+  private async loadBisqBlocksDump(cacheData: string): Promise<void> {
+    const start = new Date().getTime();
+    if (cacheData && cacheData.length !== 0) {
+      logger.debug('Processing Bisq data dump...');
+      const data: BisqBlocks = await this.jsonParsePool.exec(cacheData);
+      if (data.blocks && data.blocks.length !== this.blocks.length) {
+        this.blocks = data.blocks.filter((block) => block.txs.length > 0);
+        this.blocks.reverse();
+        this.latestBlockHeight = data.chainHeight;
+        const time = new Date().getTime() - start;
+        logger.debug('Bisq dump processed in ' + time + ' ms (worker thread)');
+      } else {
+        throw new Error(`Bisq dump didn't contain any blocks`);
+      }
+    }
+  }
+
+  private loadData(): Promise<string> {
+    return new Promise((resolve, reject) => {
+      if (!fs.existsSync(Bisq.BLOCKS_JSON_FILE_PATH)) {
+        return reject(Bisq.BLOCKS_JSON_FILE_PATH + ` doesn't exist`);
+      }
+      fs.readFile(Bisq.BLOCKS_JSON_FILE_PATH, 'utf8', (err, data) => {
+        if (err) {
+          reject(err);
+        }
+        resolve(data);
+      });
+    });
+  }
+}
+
+export default new Bisq();

backend/src/api/bisq/interfaces.ts

@@ -0,0 +1,258 @@
+
+export interface BisqBlocks {
+  chainHeight: number;
+  blocks: BisqBlock[];
+}
+
+export interface BisqBlock {
+  height: number;
+  time: number;
+  hash: string;
+  previousBlockHash: string;
+  txs: BisqTransaction[];
+}
+
+export interface BisqTransaction {
+  txVersion: string;
+  id: string;
+  blockHeight: number;
+  blockHash: string;
+  time: number;
+  inputs: BisqInput[];
+  outputs: BisqOutput[];
+  txType: string;
+  txTypeDisplayString: string;
+  burntFee: number;
+  invalidatedBsq: number;
+  unlockBlockHeight: number;
+}
+
+export interface BisqStats {
+  minted: number;
+  burnt: number;
+  addresses: number;
+  unspent_txos: number;
+  spent_txos: number;
+}
+
+interface BisqInput {
+  spendingTxOutputIndex: number;
+  spendingTxId: string;
+  bsqAmount: number;
+  isVerified: boolean;
+  address: string;
+  time: number;
+}
+
+interface BisqOutput {
+  txVersion: string;
+  txId: string;
+  index: number;
+  bsqAmount: number;
+  btcAmount: number;
+  height: number;
+  isVerified: boolean;
+  burntFee: number;
+  invalidatedBsq: number;
+  address: string;
+  scriptPubKey: BisqScriptPubKey;
+  time: any;
+  txType: string;
+  txTypeDisplayString: string;
+  txOutputType: string;
+  txOutputTypeDisplayString: string;
+  lockTime: number;
+  isUnspent: boolean;
+  spentInfo: SpentInfo;
+  opReturn?: string;
+}
+
+interface BisqScriptPubKey {
+  addresses: string[];
+  asm: string;
+  hex: string;
+  reqSigs: number;
+  type: string;
+}
+
+interface SpentInfo {
+  height: number;
+  inputIndex: number;
+  txId: string;
+}
+
+export interface BisqTrade {
+  direction: string;
+  price: string;
+  amount: string;
+  volume: string;
+  payment_method: string;
+  trade_id: string;
+  trade_date: number;
+  market?: string;
+}
+
+export interface Currencies { [txid: string]: Currency; }
+
+export interface Currency {
+  code: string;
+  name: string;
+  precision: number;
+
+  _type: string;
+}
+
+export interface Depth { [market: string]: Market; }
+
+interface Market {
+  'buys': string[];
+  'sells': string[];
+}
+
+export interface HighLowOpenClose {
+  period_start: number | string;
+  open: string;
+  high: string;
+  low: string;
+  close: string;
+  volume_left: string;
+  volume_right: string;
+  avg: string;
+}
+
+export interface Markets { [txid: string]: Pair; }
+
+interface Pair {
+  pair: string;
+  lname: string;
+  rname: string;
+  lsymbol: string;
+  rsymbol: string;
+  lprecision: number;
+  rprecision: number;
+  ltype: string;
+  rtype: string;
+  name: string;
+}
+
+export interface Offers { [market: string]: OffersMarket; }
+
+interface OffersMarket {
+  buys: Offer[] | null;
+  sells: Offer[] | null;
+}
+
+export interface OffersData {
+  direction: string;
+  currencyCode: string;
+  minAmount: number;
+  amount: number;
+  price: number;
+  date: number;
+  useMarketBasedPrice: boolean;
+  marketPriceMargin: number;
+  paymentMethod: string;
+  id: string;
+  currencyPair: string;
+  primaryMarketDirection: string;
+  priceDisplayString: string;
+  primaryMarketAmountDisplayString: string;
+  primaryMarketMinAmountDisplayString: string;
+  primaryMarketVolumeDisplayString: string;
+  primaryMarketMinVolumeDisplayString: string;
+  primaryMarketPrice: number;
+  primaryMarketAmount: number;
+  primaryMarketMinAmount: number;
+  primaryMarketVolume: number;
+  primaryMarketMinVolume: number;
+}
+
+export interface Offer {
+  offer_id: string;
+  offer_date: number;
+  direction: string;
+  min_amount: string;
+  amount: string;
+  price: string;
+  volume: string;
+  payment_method: string;
+  offer_fee_txid: any;
+}
+
+export interface Tickers { [market: string]: Ticker | null; }
+
+export interface Ticker {
+  last: string;
+  high: string;
+  low: string;
+  volume_left: string;
+  volume_right: string;
+  buy: string | null;
+  sell: string | null;
+}
+
+export interface Trade {
+  direction: string;
+  price: string;
+  amount: string;
+  volume: string;
+  payment_method: string;
+  trade_id: string;
+  trade_date: number;
+}
+
+export interface TradesData {
+  currency: string;
+  direction: string;
+  tradePrice: number;
+  tradeAmount: number;
+  tradeDate: number;
+  paymentMethod: string;
+  offerDate: number;
+  useMarketBasedPrice: boolean;
+  marketPriceMargin: number;
+  offerAmount: number;
+  offerMinAmount: number;
+  offerId: string;
+  depositTxId?: string;
+  currencyPair: string;
+  primaryMarketDirection: string;
+  primaryMarketTradePrice: number;
+  primaryMarketTradeAmount: number;
+  primaryMarketTradeVolume: number;
+
+  _market: string;
+  _tradePriceStr: string;
+  _tradeAmountStr: string;
+  _tradeVolumeStr: string;
+  _offerAmountStr: string;
+  _tradePrice: number;
+  _tradeAmount: number;
+  _tradeVolume: number;
+  _offerAmount: number;
+}
+
+export interface MarketVolume {
+  period_start: number;
+  num_trades: number;
+  volume: string;
+}
+
+export interface MarketsApiError {
+  success: number;
+  error: string;
+}
+
+export type Interval = 'minute' | 'half_hour' | 'hour' | 'half_day' | 'day' | 'week' | 'month' | 'year' | 'auto';
+
+export interface SummarizedIntervals { [market: string]: SummarizedInterval; }
+export interface SummarizedInterval {
+  'period_start': number;
+  'open': number;
+  'close': number;
+  'high': number;
+  'low': number;
+  'avg': number;
+  'volume_right': number;
+  'volume_left': number;
+}

backend/src/api/bisq/markets-api.ts

@@ -0,0 +1,655 @@
+import { Currencies, OffersData, TradesData, Depth, Currency, Interval, HighLowOpenClose,
+  Markets, Offers, Offer, BisqTrade, MarketVolume, Tickers, Ticker, SummarizedIntervals, SummarizedInterval } from './interfaces';
+
+import * as datetime from 'locutus/php/datetime';
+
+class BisqMarketsApi {
+  private cryptoCurrencyData: Currency[] = [];
+  private fiatCurrencyData: Currency[] = [];
+  private activeCryptoCurrencyData: Currency[] = [];
+  private activeFiatCurrencyData: Currency[] = [];
+  private offersData: OffersData[] = [];
+  private tradesData: TradesData[] = [];
+  private fiatCurrenciesIndexed: { [code: string]: true } = {};
+  private allCurrenciesIndexed: { [code: string]: Currency } = {};
+  private tradeDataByMarket: { [market: string]: TradesData[] } = {};
+  private tickersCache: Ticker | Tickers | null = null;
+
+  constructor() { }
+
+  setOffersData(offers: OffersData[]) {
+    this.offersData = offers;
+  }
+
+  setTradesData(trades: TradesData[]) {
+    this.tradesData = trades;
+    this.tradeDataByMarket = {};
+
+    this.tradesData.forEach((trade) => {
+      trade._market = trade.currencyPair.toLowerCase().replace('/', '_');
+      if (!this.tradeDataByMarket[trade._market]) {
+        this.tradeDataByMarket[trade._market] = [];
+      }
+      this.tradeDataByMarket[trade._market].push(trade);
+    });
+  }
+
+  setCurrencyData(cryptoCurrency: Currency[], fiatCurrency: Currency[], activeCryptoCurrency: Currency[], activeFiatCurrency: Currency[]) {
+    this.cryptoCurrencyData = cryptoCurrency,
+    this.fiatCurrencyData = fiatCurrency,
+    this.activeCryptoCurrencyData = activeCryptoCurrency,
+    this.activeFiatCurrencyData = activeFiatCurrency;
+
+    this.fiatCurrenciesIndexed = {};
+    this.allCurrenciesIndexed = {};
+
+    this.fiatCurrencyData.forEach((currency) => {
+      currency._type = 'fiat';
+      this.fiatCurrenciesIndexed[currency.code] = true;
+      this.allCurrenciesIndexed[currency.code] = currency;
+    });
+    this.cryptoCurrencyData.forEach((currency) => {
+       currency._type = 'crypto';
+       this.allCurrenciesIndexed[currency.code] = currency;
+    });
+  }
+
+  updateCache() {
+    this.tickersCache = null;
+    this.tickersCache = this.getTicker();
+  }
+
+  getCurrencies(
+    type: 'crypto' | 'fiat' | 'active' | 'all' = 'all',
+  ): Currencies {
+    let currencies: Currency[];
+
+    switch (type) {
+      case 'fiat':
+        currencies = this.fiatCurrencyData;
+        break;
+      case 'crypto':
+        currencies = this.cryptoCurrencyData;
+        break;
+      case 'active':
+        currencies = this.activeCryptoCurrencyData.concat(this.activeFiatCurrencyData);
+        break;
+      case 'all':
+      default:
+        currencies = this.cryptoCurrencyData.concat(this.fiatCurrencyData);
+    }
+    const result = {};
+    currencies.forEach((currency) => {
+      result[currency.code] = currency;
+    });
+    return result;
+  }
+
+  getDepth(
+    market: string,
+  ): Depth {
+    const currencyPair = market.replace('_', '/').toUpperCase();
+
+    const buys = this.offersData
+      .filter((offer) => offer.currencyPair === currencyPair && offer.primaryMarketDirection === 'BUY')
+      .map((offer) => offer.price)
+      .sort((a, b) => b - a)
+      .map((price) => this.intToBtc(price));
+
+    const sells = this.offersData
+      .filter((offer) => offer.currencyPair === currencyPair && offer.primaryMarketDirection === 'SELL')
+      .map((offer) => offer.price)
+      .sort((a, b) => a - b)
+      .map((price) => this.intToBtc(price));
+
+    const result = {};
+    result[market] = {
+      'buys': buys,
+      'sells': sells,
+    };
+    return result;
+  }
+
+  getOffers(
+    market: string,
+    direction?: 'buy' | 'sell',
+  ): Offers {
+    const currencyPair = market.replace('_', '/').toUpperCase();
+
+    let buys: Offer[] | null = null;
+    let sells: Offer[] | null = null;
+
+    if (!direction || direction === 'buy') {
+      buys = this.offersData
+        .filter((offer) => offer.currencyPair === currencyPair && offer.primaryMarketDirection === 'BUY')
+        .sort((a, b) => b.price - a.price)
+        .map((offer) => this.offerDataToOffer(offer, market));
+    }
+
+    if (!direction || direction === 'sell') {
+      sells = this.offersData
+        .filter((offer) => offer.currencyPair === currencyPair && offer.primaryMarketDirection === 'SELL')
+        .sort((a, b) => a.price - b.price)
+        .map((offer) => this.offerDataToOffer(offer, market));
+    }
+
+    const result: Offers = {};
+    result[market] = {
+      'buys': buys,
+      'sells': sells,
+    };
+    return result;
+  }
+
+  getMarkets(): Markets {
+    const allCurrencies = this.getCurrencies();
+    const activeCurrencies = this.getCurrencies('active');
+    const markets = {};
+
+    for (const currency of Object.keys(activeCurrencies)) {
+      if (allCurrencies[currency].code === 'BTC') {
+        continue;
+      }
+
+      const isFiat = allCurrencies[currency]._type === 'fiat';
+      const pmarketname = allCurrencies['BTC']['name'];
+
+      const lsymbol = isFiat ? 'BTC' : currency;
+      const rsymbol = isFiat ? currency : 'BTC';
+      const lname = isFiat ? pmarketname : allCurrencies[currency].name;
+      const rname = isFiat ? allCurrencies[currency].name : pmarketname;
+      const ltype = isFiat ? 'crypto' : allCurrencies[currency]._type;
+      const rtype = isFiat ? 'fiat' : 'crypto';
+      const lprecision = 8;
+      const rprecision = isFiat ? 2 : 8;
+      const pair = lsymbol.toLowerCase() + '_' + rsymbol.toLowerCase();
+
+      markets[pair] = {
+        'pair': pair,
+        'lname': lname,
+        'rname': rname,
+        'lsymbol': lsymbol,
+        'rsymbol': rsymbol,
+        'lprecision': lprecision,
+        'rprecision': rprecision,
+        'ltype': ltype,
+        'rtype': rtype,
+        'name': lname + '/' + rname,
+      };
+    }
+
+    return markets;
+  }
+
+  getTrades(
+    market: string,
+    timestamp_from?: number,
+    timestamp_to?: number,
+    trade_id_from?: string,
+    trade_id_to?: string,
+    direction?: 'buy' | 'sell',
+    limit: number = 100,
+    sort: 'asc' | 'desc' = 'desc',
+  ): BisqTrade[] {
+      limit = Math.min(limit, 2000);
+      const _market = market === 'all' ? undefined : market;
+
+      if (!timestamp_from) {
+        timestamp_from = new Date('2016-01-01').getTime() / 1000;
+      }
+      if (!timestamp_to) {
+        timestamp_to = new Date().getTime() / 1000;
+      }
+
+      const matches = this.getTradesByCriteria(_market, timestamp_to, timestamp_from,
+        trade_id_to, trade_id_from, direction, sort, limit, false);
+
+      if (sort === 'asc') {
+        matches.sort((a, b) => a.tradeDate - b.tradeDate);
+      } else {
+        matches.sort((a, b) => b.tradeDate - a.tradeDate);
+      }
+
+      return matches.map((trade) => {
+        const bsqTrade: BisqTrade = {
+          direction: trade.primaryMarketDirection,
+          price: trade._tradePriceStr,
+          amount: trade._tradeAmountStr,
+          volume: trade._tradeVolumeStr,
+          payment_method: trade.paymentMethod,
+          trade_id: trade.offerId,
+          trade_date: trade.tradeDate,
+        };
+        if (market === 'all') {
+          bsqTrade.market = trade._market;
+        }
+        return bsqTrade;
+      });
+  }
+
+  getVolumes(
+    market?: string,
+    timestamp_from?: number,
+    timestamp_to?: number,
+    interval: Interval = 'auto',
+    milliseconds?: boolean,
+    timestamp: 'no' | 'yes' = 'yes',
+  ): MarketVolume[] {
+    if (milliseconds) {
+      timestamp_from = timestamp_from ? timestamp_from / 1000 : timestamp_from;
+      timestamp_to = timestamp_to ? timestamp_to / 1000 : timestamp_to;
+    }
+    if (!timestamp_from) {
+      timestamp_from = new Date('2016-01-01').getTime() / 1000;
+    }
+    if (!timestamp_to) {
+      timestamp_to = new Date().getTime() / 1000;
+    }
+
+    const trades = this.getTradesByCriteria(market, timestamp_to, timestamp_from,
+      undefined, undefined, undefined, 'asc', Number.MAX_SAFE_INTEGER);
+
+    if (interval === 'auto') {
+      const range = timestamp_to - timestamp_from;
+      interval = this.getIntervalFromRange(range);
+    }
+
+    const intervals: any = {};
+    const marketVolumes: MarketVolume[] = [];
+
+    for (const trade of trades) {
+      const traded_at = trade['tradeDate'] / 1000;
+      const interval_start = this.intervalStart(traded_at, interval);
+
+      if (!intervals[interval_start]) {
+        intervals[interval_start] = {
+          'volume': 0,
+          'num_trades': 0,
+        };
+      }
+
+      const period = intervals[interval_start];
+      period['period_start'] = interval_start;
+      period['volume'] += this.fiatCurrenciesIndexed[trade.currency] ? trade._tradeAmount : trade._tradeVolume;
+      period['num_trades']++;
+    }
+
+    for (const p in intervals) {
+      if (intervals.hasOwnProperty(p)) {
+        const period = intervals[p];
+        marketVolumes.push({
+          period_start: timestamp === 'no' ? new Date(period['period_start'] * 1000).toISOString() : period['period_start'],
+          num_trades: period['num_trades'],
+          volume: this.intToBtc(period['volume']),
+        });
+      }
+    }
+
+    return marketVolumes;
+  }
+
+  getTicker(
+    market?: string,
+  ): Tickers | Ticker | null {
+    if (market) {
+      return this.getTickerFromMarket(market);
+    }
+
+    if (this.tickersCache) {
+      return this.tickersCache;
+    }
+
+    const allMarkets = this.getMarkets();
+    const tickers = {};
+    for (const m in allMarkets) {
+      if (allMarkets.hasOwnProperty(m)) {
+        tickers[allMarkets[m].pair] = this.getTickerFromMarket(allMarkets[m].pair);
+      }
+    }
+
+    return tickers;
+  }
+
+  getTickerFromMarket(market: string): Ticker | null {
+    let ticker: Ticker;
+    const timestamp_from = datetime.strtotime('-24 hour');
+    const timestamp_to = new Date().getTime() / 1000;
+    const trades = this.getTradesByCriteria(market, timestamp_to, timestamp_from,
+      undefined, undefined, undefined, 'asc', Number.MAX_SAFE_INTEGER);
+
+    const periods: SummarizedInterval[] = Object.values(this.getTradesSummarized(trades, timestamp_from));
+
+    const allCurrencies = this.getCurrencies();
+    const currencyRight = allCurrencies[market.split('_')[1].toUpperCase()];
+
+    if (periods[0]) {
+      ticker = {
+        'last': this.intToBtc(periods[0].close),
+        'high': this.intToBtc(periods[0].high),
+        'low': this.intToBtc(periods[0].low),
+        'volume_left': this.intToBtc(periods[0].volume_left),
+        'volume_right': this.intToBtc(periods[0].volume_right),
+        'buy': null,
+        'sell': null,
+      };
+    } else {
+      const lastTrade = this.tradeDataByMarket[market];
+      if (!lastTrade) {
+        return null;
+      }
+      const tradePrice = lastTrade[0].primaryMarketTradePrice * Math.pow(10, 8 - currencyRight.precision);
+
+      const lastTradePrice = this.intToBtc(tradePrice);
+      ticker = {
+        'last': lastTradePrice,
+        'high': lastTradePrice,
+        'low': lastTradePrice,
+        'volume_left': '0',
+        'volume_right': '0',
+        'buy': null,
+        'sell': null,
+      };
+    }
+
+    const timestampFromMilli = timestamp_from * 1000;
+    const timestampToMilli = timestamp_to * 1000;
+
+    const currencyPair = market.replace('_', '/').toUpperCase();
+    const offersData = this.offersData.slice().sort((a, b) => a.price - b.price);
+
+    const buy = offersData.find((offer) => offer.currencyPair === currencyPair
+                                          && offer.primaryMarketDirection === 'BUY'
+                                          && offer.date >= timestampFromMilli
+                                          && offer.date <= timestampToMilli
+                                        );
+    const sell = offersData.find((offer) => offer.currencyPair === currencyPair
+                                            && offer.primaryMarketDirection === 'SELL'
+                                            && offer.date >= timestampFromMilli
+                                            && offer.date <= timestampToMilli
+                                          );
+
+    if (buy) {
+      ticker.buy = this.intToBtc(buy.primaryMarketPrice * Math.pow(10, 8 - currencyRight.precision));
+    }
+    if (sell) {
+      ticker.sell = this.intToBtc(sell.primaryMarketPrice * Math.pow(10, 8 - currencyRight.precision));
+    }
+
+    return ticker;
+  }
+
+  getHloc(
+    market: string,
+    interval: Interval = 'auto',
+    timestamp_from?: number,
+    timestamp_to?: number,
+    milliseconds?: boolean,
+    timestamp: 'no' | 'yes' = 'yes',
+  ): HighLowOpenClose[] {
+    if (milliseconds) {
+      timestamp_from = timestamp_from ? timestamp_from / 1000 : timestamp_from;
+      timestamp_to = timestamp_to ? timestamp_to / 1000 : timestamp_to;
+    }
+    if (!timestamp_from) {
+      timestamp_from = new Date('2016-01-01').getTime() / 1000;
+    }
+    if (!timestamp_to) {
+      timestamp_to = new Date().getTime() / 1000;
+    }
+
+    const trades = this.getTradesByCriteria(market, timestamp_to, timestamp_from,
+      undefined, undefined, undefined, 'asc', Number.MAX_SAFE_INTEGER);
+
+    if (interval === 'auto') {
+      const range = timestamp_to - timestamp_from;
+      interval = this.getIntervalFromRange(range);
+    }
+
+    const intervals = this.getTradesSummarized(trades, timestamp_from, interval);
+
+    const hloc: HighLowOpenClose[] = [];
+
+    for (const p in intervals) {
+      if (intervals.hasOwnProperty(p)) {
+        const period = intervals[p];
+        hloc.push({
+          period_start: timestamp === 'no' ? new Date(period['period_start'] * 1000).toISOString() : period['period_start'],
+          open: this.intToBtc(period['open']),
+          close: this.intToBtc(period['close']),
+          high: this.intToBtc(period['high']),
+          low: this.intToBtc(period['low']),
+          avg: this.intToBtc(period['avg']),
+          volume_right: this.intToBtc(period['volume_right']),
+          volume_left: this.intToBtc(period['volume_left']),
+        });
+      }
+    }
+
+    return hloc;
+  }
+
+  private getIntervalFromRange(range: number): Interval {
+    // two days range loads minute data
+    if (range <= 3600) {
+      // up to one hour range loads minutely data
+      return 'minute';
+    } else if (range <= 1 * 24 * 3600) {
+      // up to one day range loads half-hourly data
+      return 'half_hour';
+    } else if (range <= 3 * 24 * 3600) {
+      // up to 3 day range loads hourly data
+      return 'hour';
+    } else if (range <= 7 * 24 * 3600) {
+      // up to 7 day range loads half-daily data
+      return 'half_day';
+    } else if (range <= 60 * 24 * 3600) {
+      // up to 2 month range loads daily data
+      return 'day';
+    } else if (range <= 12 * 31 * 24 * 3600) {
+      // up to one year range loads weekly data
+      return 'week';
+    } else if (range <= 12 * 31 * 24 * 3600) {
+      // up to 5 year range loads monthly data
+      return 'month';
+    } else {
+      // greater range loads yearly data
+      return 'year';
+    }
+  }
+
+  private getTradesSummarized(trades: TradesData[], timestamp_from: number, interval?: string): SummarizedIntervals {
+    const intervals: any = {};
+    const intervals_prices: any = {};
+
+    for (const trade of trades) {
+      const traded_at = trade.tradeDate / 1000;
+      const interval_start = !interval ? timestamp_from : this.intervalStart(traded_at, interval);
+
+      if (!intervals[interval_start]) {
+          intervals[interval_start] = {
+            'open': 0,
+            'close': 0,
+            'high': 0,
+            'low': 0,
+            'avg': 0,
+            'volume_right': 0,
+            'volume_left': 0,
+        };
+        intervals_prices[interval_start] = [];
+      }
+      const period = intervals[interval_start];
+      const price = trade._tradePrice;
+
+      if (!intervals_prices[interval_start]['leftvol']) {
+        intervals_prices[interval_start]['leftvol'] = [];
+      }
+      if (!intervals_prices[interval_start]['rightvol']) {
+        intervals_prices[interval_start]['rightvol'] = [];
+      }
+
+      intervals_prices[interval_start]['leftvol'].push(trade._tradeAmount);
+      intervals_prices[interval_start]['rightvol'].push(trade._tradeVolume);
+
+      if (price) {
+          const plow = period['low'];
+          period['period_start'] = interval_start;
+          period['open'] = period['open'] || price;
+          period['close'] = price;
+          period['high'] = price > period['high'] ? price : period['high'];
+          period['low'] = (plow && price > plow) ? period['low'] : price;
+          period['avg'] = intervals_prices[interval_start]['rightvol'].reduce((p: number, c: number) => c + p, 0)
+            / intervals_prices[interval_start]['leftvol'].reduce((c: number, p: number) => c + p, 0) * 100000000;
+          period['volume_left'] += trade._tradeAmount;
+          period['volume_right'] += trade._tradeVolume;
+      }
+    }
+    return intervals;
+  }
+
+  private getTradesByCriteria(
+    market: string | undefined,
+    timestamp_to: number,
+    timestamp_from: number,
+    trade_id_to: string | undefined,
+    trade_id_from: string | undefined,
+    direction: 'buy' | 'sell' | undefined,
+    sort: string,
+    limit: number,
+    integerAmounts: boolean = true,
+ ): TradesData[] {
+    let trade_id_from_ts: number | null = null;
+    let trade_id_to_ts: number | null = null;
+    const allCurrencies = this.getCurrencies();
+
+    const timestampFromMilli = timestamp_from * 1000;
+    const timestampToMilli = timestamp_to * 1000;
+
+    // note: the offer_id_from/to depends on iterating over trades in
+    // descending chronological order.
+    const tradesDataSorted = this.tradesData.slice();
+    if (sort === 'asc') {
+      tradesDataSorted.reverse();
+    }
+
+    let matches: TradesData[] = [];
+    for (const trade of tradesDataSorted) {
+      if (trade_id_from === trade.offerId) {
+        trade_id_from_ts = trade.tradeDate;
+      }
+      if (trade_id_to === trade.offerId) {
+        trade_id_to_ts = trade.tradeDate;
+      }
+      if (trade_id_to && trade_id_to_ts === null) {
+        continue;
+      }
+      if (trade_id_from && trade_id_from_ts != null && trade_id_from_ts !== trade.tradeDate) {
+        continue;
+      }
+      if (market && market !== trade._market) {
+        continue;
+      }
+      if (timestampFromMilli && timestampFromMilli > trade.tradeDate) {
+        continue;
+      }
+      if (timestampToMilli && timestampToMilli < trade.tradeDate) {
+        continue;
+      }
+      if (direction && direction !== trade.direction.toLowerCase()) {
+        continue;
+      }
+
+      // Filter out bogus trades with BTC/BTC or XXX/XXX market.
+      // See github issue: https://github.com/bitsquare/bitsquare/issues/883
+      const currencyPairs = trade.currencyPair.split('/');
+      if (currencyPairs[0] === currencyPairs[1]) {
+        continue;
+      }
+
+      const currencyLeft = allCurrencies[currencyPairs[0]];
+      const currencyRight = allCurrencies[currencyPairs[1]];
+
+      if (!currencyLeft || !currencyRight) {
+        continue;
+      }
+
+      const tradePrice = trade.primaryMarketTradePrice * Math.pow(10, 8 - currencyRight.precision);
+      const tradeAmount = trade.primaryMarketTradeAmount * Math.pow(10, 8 - currencyLeft.precision);
+      const tradeVolume = trade.primaryMarketTradeVolume * Math.pow(10, 8 - currencyRight.precision);
+
+      if (integerAmounts) {
+        trade._tradePrice = tradePrice;
+        trade._tradeAmount = tradeAmount;
+        trade._tradeVolume = tradeVolume;
+        trade._offerAmount = trade.offerAmount;
+      } else {
+        trade._tradePriceStr = this.intToBtc(tradePrice);
+        trade._tradeAmountStr = this.intToBtc(tradeAmount);
+        trade._tradeVolumeStr = this.intToBtc(tradeVolume);
+        trade._offerAmountStr = this.intToBtc(trade.offerAmount);
+      }
+
+      matches.push(trade);
+
+      if (matches.length >= limit) {
+        break;
+      }
+    }
+
+    if ((trade_id_from && !trade_id_from_ts) || (trade_id_to && !trade_id_to_ts)) {
+      matches = [];
+    }
+    return matches;
+  }
+
+  private intervalStart(ts: number, interval: string): number {
+    switch (interval) {
+        case 'minute':
+            return (ts - (ts % 60));
+        case '10_minute':
+            return (ts - (ts % 600));
+        case 'half_hour':
+            return (ts - (ts % 1800));
+        case 'hour':
+            return (ts - (ts % 3600));
+        case 'half_day':
+            return (ts - (ts % (3600 * 12)));
+        case 'day':
+            return datetime.strtotime('midnight today', ts);
+        case 'week':
+            return datetime.strtotime('midnight sunday last week', ts);
+        case 'month':
+            return datetime.strtotime('midnight first day of this month', ts);
+        case 'year':
+            return datetime.strtotime('midnight first day of january', ts);
+        default:
+            throw new Error('Unsupported interval: ' + interval);
+    }
+}
+
+  private offerDataToOffer(offer: OffersData, market: string): Offer {
+    const currencyPairs = market.split('_');
+    const currencyRight = this.allCurrenciesIndexed[currencyPairs[1].toUpperCase()];
+    const currencyLeft = this.allCurrenciesIndexed[currencyPairs[0].toUpperCase()];
+    const price = offer['primaryMarketPrice'] * Math.pow( 10, 8 - currencyRight['precision']);
+    const amount = offer['primaryMarketAmount'] * Math.pow( 10, 8 - currencyLeft['precision']);
+    const volume = offer['primaryMarketVolume'] * Math.pow( 10, 8 - currencyRight['precision']);
+
+    return {
+      offer_id: offer.id,
+      offer_date: offer.date,
+      direction: offer.primaryMarketDirection,
+      min_amount: this.intToBtc(offer.minAmount),
+      amount: this.intToBtc(amount),
+      price: this.intToBtc(price),
+      volume: this.intToBtc(volume),
+      payment_method: offer.paymentMethod,
+      offer_fee_txid: null,
+    };
+  }
+
+  private intToBtc(val: number): string {
+    return (val / 100000000).toFixed(8);
+  }
+}
+
+export default new BisqMarketsApi();

backend/src/api/bisq/markets.ts

@@ -0,0 +1,131 @@
+import config from '../../config';
+import * as fs from 'fs';
+import { OffersData as OffersData, TradesData, Currency } from './interfaces';
+import bisqMarket from './markets-api';
+import logger from '../../logger';
+
+class Bisq {
+  private static FOLDER_WATCH_CHANGE_DETECTION_DEBOUNCE = 4000;
+  private static MARKET_JSON_PATH = config.BISQ_MARKETS.DATA_PATH;
+  private static MARKET_JSON_FILE_PATHS = {
+    activeCryptoCurrency: '/active_crypto_currency_list.json',
+    activeFiatCurrency: '/active_fiat_currency_list.json',
+    cryptoCurrency: '/crypto_currency_list.json',
+    fiatCurrency: '/fiat_currency_list.json',
+    offers: '/offers_statistics.json',
+    trades: '/trade_statistics.json',
+  };
+
+  private cryptoCurrencyLastMtime = new Date('2016-01-01');
+  private fiatCurrencyLastMtime = new Date('2016-01-01');
+  private offersLastMtime = new Date('2016-01-01');
+  private tradesLastMtime = new Date('2016-01-01');
+
+  private subdirectoryWatcher: fs.FSWatcher | undefined;
+
+  constructor() {}
+
+  startBisqService(): void {
+    this.checkForBisqDataFolder();
+    this.loadBisqDumpFile();
+    this.startBisqDirectoryWatcher();
+  }
+
+  private checkForBisqDataFolder() {
+    if (!fs.existsSync(Bisq.MARKET_JSON_PATH + Bisq.MARKET_JSON_FILE_PATHS.cryptoCurrency)) {
+      logger.err(Bisq.MARKET_JSON_PATH + Bisq.MARKET_JSON_FILE_PATHS.cryptoCurrency + ` doesn't exist. Make sure Bisq is running and the config is correct before starting the server.`);
+      return process.exit(1);
+    }
+  }
+
+  private startBisqDirectoryWatcher() {
+    if (this.subdirectoryWatcher) {
+      this.subdirectoryWatcher.close();
+    }
+    if (!fs.existsSync(Bisq.MARKET_JSON_PATH + Bisq.MARKET_JSON_FILE_PATHS.cryptoCurrency)) {
+      logger.warn(Bisq.MARKET_JSON_PATH + Bisq.MARKET_JSON_FILE_PATHS.cryptoCurrency + ` doesn't exist. Trying to restart sub directory watcher again in 3 minutes.`);
+      setTimeout(() => this.startBisqDirectoryWatcher(), 180000);
+      return;
+    }
+    let fsWait: NodeJS.Timeout | null = null;
+    this.subdirectoryWatcher = fs.watch(Bisq.MARKET_JSON_PATH, () => {
+      if (fsWait) {
+        clearTimeout(fsWait);
+      }
+      fsWait = setTimeout(() => {
+        logger.debug(`Change detected in the Bisq market data folder.`);
+        this.loadBisqDumpFile();
+      }, Bisq.FOLDER_WATCH_CHANGE_DETECTION_DEBOUNCE);
+    });
+  }
+
+  private async loadBisqDumpFile(): Promise<void> {
+    const start = new Date().getTime();
+    try {
+      let marketsDataUpdated = false;
+      const cryptoMtime = this.getFileMtime(Bisq.MARKET_JSON_FILE_PATHS.cryptoCurrency);
+      const fiatMtime = this.getFileMtime(Bisq.MARKET_JSON_FILE_PATHS.fiatCurrency);
+      if (cryptoMtime > this.cryptoCurrencyLastMtime || fiatMtime > this.fiatCurrencyLastMtime) {
+        const cryptoCurrencyData = await this.loadData<Currency[]>(Bisq.MARKET_JSON_FILE_PATHS.cryptoCurrency);
+        const fiatCurrencyData = await this.loadData<Currency[]>(Bisq.MARKET_JSON_FILE_PATHS.fiatCurrency);
+        const activeCryptoCurrencyData = await this.loadData<Currency[]>(Bisq.MARKET_JSON_FILE_PATHS.activeCryptoCurrency);
+        const activeFiatCurrencyData = await this.loadData<Currency[]>(Bisq.MARKET_JSON_FILE_PATHS.activeFiatCurrency);
+        logger.debug('Updating Bisq Market Currency Data');
+        bisqMarket.setCurrencyData(cryptoCurrencyData, fiatCurrencyData, activeCryptoCurrencyData, activeFiatCurrencyData);
+        if (cryptoMtime > this.cryptoCurrencyLastMtime) {
+          this.cryptoCurrencyLastMtime = cryptoMtime;
+        }
+        if (fiatMtime > this.fiatCurrencyLastMtime) {
+          this.fiatCurrencyLastMtime = fiatMtime;
+        }
+        marketsDataUpdated = true;
+      }
+      const offersMtime = this.getFileMtime(Bisq.MARKET_JSON_FILE_PATHS.offers);
+      if (offersMtime > this.offersLastMtime) {
+        const offersData = await this.loadData<OffersData[]>(Bisq.MARKET_JSON_FILE_PATHS.offers);
+        logger.debug('Updating Bisq Market Offers Data');
+        bisqMarket.setOffersData(offersData);
+        this.offersLastMtime = offersMtime;
+        marketsDataUpdated = true;
+      }
+      const tradesMtime = this.getFileMtime(Bisq.MARKET_JSON_FILE_PATHS.trades);
+      if (tradesMtime > this.tradesLastMtime) {
+        const tradesData = await this.loadData<TradesData[]>(Bisq.MARKET_JSON_FILE_PATHS.trades);
+        logger.debug('Updating Bisq Market Trades Data');
+        bisqMarket.setTradesData(tradesData);
+        this.tradesLastMtime = tradesMtime;
+        marketsDataUpdated = true;
+      }
+      if (marketsDataUpdated) {
+        bisqMarket.updateCache();
+        const time = new Date().getTime() - start;
+        logger.debug('Bisq market data updated in ' + time + ' ms');
+      }
+    } catch (e) {
+      logger.err('loadBisqMarketDataDumpFile() error.' + e.message || e);
+    }
+  }
+
+  private getFileMtime(path: string): Date {
+    const stats = fs.statSync(Bisq.MARKET_JSON_PATH + path);
+    return stats.mtime;
+  }
+
+  private loadData<T>(path: string): Promise<T> {
+    return new Promise((resolve, reject) => {
+      fs.readFile(Bisq.MARKET_JSON_PATH + path, 'utf8', (err, data) => {
+        if (err) {
+          reject(err);
+        }
+        try {
+          const parsedData = JSON.parse(data);
+          resolve(parsedData);
+        } catch (e) {
+          reject('JSON parse error (' + path + ')');
+        }
+      });
+    });
+  }
+}
+
+export default new Bisq();

backend/src/api/bitcoin/bitcoin-api-abstract-factory.ts

@@ -1,19 +1,14 @@
-import { IMempoolInfo, ITransaction, IBlock } from '../../interfaces';
+import { IEsploraApi } from './esplora-api.interface';
 
 export interface AbstractBitcoinApi {
-  getMempoolInfo(): Promise<IMempoolInfo>;
-  getRawMempool(): Promise<ITransaction['txid'][]>;
-  getRawTransaction(txId: string): Promise<ITransaction>;
-  getBlockCount(): Promise<number>;
-  getBlockAndTransactions(hash: string): Promise<IBlock>;
-  getBlockHash(height: number): Promise<string>;
-
-  getBlock(hash: string): Promise<IBlock>;
-  getBlockTransactions(hash: string): Promise<IBlock>;
-  getBlockTransactionsFromIndex(hash: string, index: number): Promise<IBlock>;
-  getBlocks(): Promise<string>;
-  getBlocksFromHeight(height: number): Promise<string>;
-  getAddress(address: string): Promise<IBlock>;
-  getAddressTransactions(address: string): Promise<IBlock>;
-  getAddressTransactionsFromLastSeenTxid(address: string, lastSeenTxid: string): Promise<IBlock>;
+  $getRawMempool(): Promise<IEsploraApi.Transaction['txid'][]>;
+  $getRawTransaction(txId: string, skipConversion?: boolean, addPrevout?: boolean): Promise<IEsploraApi.Transaction>;
+  $getRawTransactionBitcoind(txId: string, skipConversion?: boolean, addPrevout?: boolean): Promise<IEsploraApi.Transaction>;
+  $getBlockHeightTip(): Promise<number>;
+  $getTxIdsForBlock(hash: string): Promise<string[]>;
+  $getBlockHash(height: number): Promise<string>;
+  $getBlock(hash: string): Promise<IEsploraApi.Block>;
+  $getAddress(address: string): Promise<IEsploraApi.Address>;
+  $getAddressTransactions(address: string, lastSeenTxId: string): Promise<IEsploraApi.Transaction[]>;
+  $getAddressPrefix(prefix: string): string[];
 }

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

@@ -1,16 +1,19 @@
-const config = require('../../../mempool-config.json');
+import config from '../../config';
 import { AbstractBitcoinApi } from './bitcoin-api-abstract-factory';
-import BitcoindApi from './bitcoind-api';
-import ElectrsApi from './electrs-api';
+import EsploraApi from './esplora-api';
+import BitcoinApi from './bitcoin-api';
+import ElectrumApi from './electrum-api';
 
-function factory(): AbstractBitcoinApi {
-  switch (config.BACKEND_API) {
-    case 'electrs':
-      return new ElectrsApi();
-    case 'bitcoind':
+function bitcoinApiFactory(): AbstractBitcoinApi {
+  switch (config.MEMPOOL.BACKEND) {
+    case 'esplora':
+      return new EsploraApi();
+    case 'electrum':
+      return new ElectrumApi();
+    case 'none':
     default:
-      return new BitcoindApi();
+      return new BitcoinApi();
   }
 }
 
-export default factory();
+export default bitcoinApiFactory();

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

@@ -0,0 +1,116 @@
+export namespace IBitcoinApi {
+  export interface MempoolInfo {
+    loaded: boolean;                 //  (boolean) True if the mempool is fully loaded
+    size: number;                    //  (numeric) Current tx count
+    bytes: number;                   //  (numeric) Sum of all virtual transaction sizes as defined in BIP 141.
+    usage: number;                   //  (numeric) Total memory usage for the mempool
+    maxmempool: number;              //  (numeric) Maximum memory usage for the mempool
+    mempoolminfee: number;           //  (numeric) Minimum fee rate in BTC/kB for tx to be accepted.
+    minrelaytxfee: number;           //  (numeric) Current minimum relay fee for transactions
+  }
+
+  export interface RawMempool { [txId: string]: MempoolEntry; }
+
+  export interface MempoolEntry {
+    vsize: number;                   //  (numeric) virtual transaction size as defined in BIP 141.
+    weight: number;                  //  (numeric) transaction weight as defined in BIP 141.
+    time: number;                    //  (numeric) local time transaction entered pool in seconds since 1 Jan 1970 GMT
+    height: number;                  //  (numeric) block height when transaction entered pool
+    descendantcount: number;         //  (numeric) number of in-mempool descendant transactions (including this one)
+    descendantsize: number;          //  (numeric) virtual transaction size of in-mempool descendants (including this one)
+    ancestorcount: number;           //  (numeric) number of in-mempool ancestor transactions (including this one)
+    ancestorsize: number;            //  (numeric) virtual transaction size of in-mempool ancestors (including this one)
+    wtxid: string;                   //  (string) hash of serialized transactionumber; including witness data
+    fees: {
+      base: number;                  //  (numeric) transaction fee in BTC
+      modified: number;              //  (numeric) transaction fee with fee deltas used for mining priority in BTC
+      ancestor: number;              //  (numeric) modified fees (see above) of in-mempool ancestors (including this one) in BTC
+      descendant: number;            //  (numeric) modified fees (see above) of in-mempool descendants (including this one) in BTC
+    };
+    depends: string[];               //  (string) parent transaction id
+    spentby: string[];               //  (array) unconfirmed transactions spending outputs from this transaction
+    'bip125-replaceable': boolean;   //  (boolean) Whether this transaction could be replaced due to BIP125 (replace-by-fee)
+  }
+
+  export interface Block {
+    hash: string;                    //  (string) the block hash (same as provided)
+    confirmations: number;           //  (numeric) The number of confirmations, or -1 if the block is not on the main chain
+    size: number;                    //  (numeric) The block size
+    strippedsize: number;            //  (numeric) The block size excluding witness data
+    weight: number;                  //  (numeric) The block weight as defined in BIP 141
+    height: number;                  //  (numeric) The block height or index
+    version: number;                 //  (numeric) The block version
+    versionHex: string;              //  (string) The block version formatted in hexadecimal
+    merkleroot: string;              //  (string) The merkle root
+    tx: Transaction[];
+    time: number;                    //  (numeric) The block time expressed in UNIX epoch time
+    mediantime: number;              //  (numeric) The median block time expressed in UNIX epoch time
+    nonce: number;                   //  (numeric) The nonce
+    bits: string;                    //  (string) The bits
+    difficulty: number;              //  (numeric) The difficulty
+    chainwork: string;               //  (string) Expected number of hashes required to produce the chain up to this block (in hex)
+    nTx: number;                     //  (numeric) The number of transactions in the block
+    previousblockhash: string;       //  (string) The hash of the previous block
+    nextblockhash: string;           //  (string) The hash of the next block
+  }
+
+  export interface Transaction {
+    in_active_chain: boolean;        //  (boolean) Whether specified block is in the active chain or not
+    hex: string;                     //  (string) The serialized, hex-encoded data for 'txid'
+    txid: string;                    //  (string) The transaction id (same as provided)
+    hash: string;                    //  (string) The transaction hash (differs from txid for witness transactions)
+    size: number;                    //  (numeric) The serialized transaction size
+    vsize: number;                   //  (numeric) The virtual transaction size (differs from size for witness transactions)
+    weight: number;                  //  (numeric) The transaction's weight (between vsize*4-3 and vsize*4)
+    version: number;                 //  (numeric) The version
+    locktime: number;                //  (numeric) The lock time
+    vin: Vin[];
+    vout: Vout[];
+    blockhash: string;               //  (string) the block hash
+    confirmations: number;           //  (numeric) The confirmations
+    blocktime: number;               //  (numeric) The block time expressed in UNIX epoch time
+    time: number;                    //  (numeric) Same as blocktime
+  }
+
+  interface Vin {
+    txid?: string;                   //  (string) The transaction id
+    vout?: number;                   //  (string)
+    scriptSig?: {                    //  (json object) The script
+      asm: string;                   //  (string) asm
+      hex: string;                   //  (string) hex
+    };
+    sequence: number;                //  (numeric) The script sequence number
+    txinwitness?: string[];          //  (string) hex-encoded witness data
+    coinbase?: string;
+  }
+
+  interface Vout {
+    value: number;                   //  (numeric) The value in BTC
+    n: number;                       //  (numeric) index
+    scriptPubKey: {                  //  (json object)
+      asm: string;                   //  (string) the asm
+      hex: string;                   //  (string) the hex
+      reqSigs: number;               //  (numeric) The required sigs
+      type: string;                  //  (string) The type, eg 'pubkeyhash'
+      addresses: string[]            //  (string) bitcoin address
+    };
+  }
+
+  export interface AddressInformation {
+    isvalid: boolean;                //  (boolean) If the address is valid or not. If not, this is the only property returned.
+    address: string;                 //  (string) The bitcoin address validated
+    scriptPubKey: string;            //  (string) The hex-encoded scriptPubKey generated by the address
+    isscript: boolean;               //  (boolean) If the key is a script
+    iswitness: boolean;              //  (boolean) If the address is a witness
+    witness_version?: boolean;       //  (numeric, optional) The version number of the witness program
+    witness_program: string;         //  (string, optional) The hex value of the witness program
+  }
+
+  export interface ChainTips {
+    height: number;                  //  (numeric) height of the chain tip
+    hash: string;                    //  (string) block hash of the tip
+    branchlen: number;               //  (numeric) zero for main chain, otherwise length of branch connecting the tip to the main chain
+    status: 'invalid' | 'headers-only' | 'valid-headers' | 'valid-fork' | 'active';
+  }
+
+}

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

@@ -0,0 +1,309 @@
+import config from '../../config';
+import * as bitcoin from '@mempool/bitcoin';
+import * as bitcoinjs from 'bitcoinjs-lib';
+import { AbstractBitcoinApi } from './bitcoin-api-abstract-factory';
+import { IBitcoinApi } from './bitcoin-api.interface';
+import { IEsploraApi } from './esplora-api.interface';
+import blocks from '../blocks';
+import mempool from '../mempool';
+import { TransactionExtended } from '../../mempool.interfaces';
+
+class BitcoinApi implements AbstractBitcoinApi {
+  private rawMempoolCache: IBitcoinApi.RawMempool | null = null;
+  private bitcoindClient: any;
+
+  constructor() {
+    this.bitcoindClient = new bitcoin.Client({
+      host: config.CORE_RPC.HOST,
+      port: config.CORE_RPC.PORT,
+      user: config.CORE_RPC.USERNAME,
+      pass: config.CORE_RPC.PASSWORD,
+      timeout: 60000,
+    });
+  }
+
+  $getRawTransactionBitcoind(txId: string, skipConversion = false, addPrevout = false): Promise<IEsploraApi.Transaction> {
+    return this.bitcoindClient.getRawTransaction(txId, true)
+      .then((transaction: IBitcoinApi.Transaction) => {
+        if (skipConversion) {
+          return transaction;
+        }
+        return this.$convertTransaction(transaction, addPrevout);
+      });
+  }
+
+  $getRawTransaction(txId: string, skipConversion = false, addPrevout = false): Promise<IEsploraApi.Transaction> {
+    // If the transaction is in the mempool we already converted and fetched the fee. Only prevouts are missing
+    const txInMempool = mempool.getMempool()[txId];
+    if (txInMempool && addPrevout) {
+      return this.$addPrevouts(txInMempool);
+    }
+
+    // Special case to fetch the Coinbase transaction
+    if (txId === '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b') {
+      return this.$returnCoinbaseTransaction();
+    }
+
+    return this.bitcoindClient.getRawTransaction(txId, true)
+      .then((transaction: IBitcoinApi.Transaction) => {
+        if (skipConversion) {
+          return transaction;
+        }
+        return this.$convertTransaction(transaction, addPrevout);
+      });
+  }
+
+  $getBlockHeightTip(): Promise<number> {
+    return this.bitcoindClient.getChainTips()
+      .then((result: IBitcoinApi.ChainTips[]) => result[0].height);
+  }
+
+  $getTxIdsForBlock(hash: string): Promise<string[]> {
+    return this.bitcoindClient.getBlock(hash, 1)
+      .then((rpcBlock: IBitcoinApi.Block) => rpcBlock.tx);
+  }
+
+  $getBlockHash(height: number): Promise<string> {
+    return this.bitcoindClient.getBlockHash(height);
+  }
+
+  async $getBlock(hash: string): Promise<IEsploraApi.Block> {
+    const foundBlock = blocks.getBlocks().find((block) => block.id === hash);
+    if (foundBlock) {
+      return foundBlock;
+    }
+
+    return this.bitcoindClient.getBlock(hash)
+      .then((block: IBitcoinApi.Block) => this.convertBlock(block));
+  }
+
+  $getAddress(address: string): Promise<IEsploraApi.Address> {
+    throw new Error('Method getAddress not supported by the Bitcoin RPC API.');
+  }
+
+  $getAddressTransactions(address: string, lastSeenTxId: string): Promise<IEsploraApi.Transaction[]> {
+    throw new Error('Method getAddressTransactions not supported by the Bitcoin RPC API.');
+  }
+
+  $getRawMempool(): Promise<IEsploraApi.Transaction['txid'][]> {
+    return this.bitcoindClient.getRawMemPool();
+  }
+
+  $getAddressPrefix(prefix: string): string[] {
+    const found: string[] = [];
+    const mp = mempool.getMempool();
+    for (const tx in mp) {
+      for (const vout of mp[tx].vout) {
+        if (vout.scriptpubkey_address.indexOf(prefix) === 0) {
+          found.push(vout.scriptpubkey_address);
+          if (found.length >= 10) {
+            return found;
+          }
+        }
+      }
+    }
+    return found;
+  }
+
+  protected async $convertTransaction(transaction: IBitcoinApi.Transaction, addPrevout: boolean): Promise<IEsploraApi.Transaction> {
+    let esploraTransaction: IEsploraApi.Transaction = {
+      txid: transaction.txid,
+      version: transaction.version,
+      locktime: transaction.locktime,
+      size: transaction.size,
+      weight: transaction.weight,
+      fee: 0,
+      vin: [],
+      vout: [],
+      status: { confirmed: false },
+    };
+
+    esploraTransaction.vout = transaction.vout.map((vout) => {
+      return {
+        value: vout.value * 100000000,
+        scriptpubkey: vout.scriptPubKey.hex,
+        scriptpubkey_address: vout.scriptPubKey && vout.scriptPubKey.addresses ? vout.scriptPubKey.addresses[0] : '',
+        scriptpubkey_asm: vout.scriptPubKey.asm ? this.convertScriptSigAsm(vout.scriptPubKey.asm) : '',
+        scriptpubkey_type: this.translateScriptPubKeyType(vout.scriptPubKey.type),
+      };
+    });
+
+    esploraTransaction.vin = transaction.vin.map((vin) => {
+      return {
+        is_coinbase: !!vin.coinbase,
+        prevout: null,
+        scriptsig: vin.scriptSig && vin.scriptSig.hex || vin.coinbase || '',
+        scriptsig_asm: vin.scriptSig && this.convertScriptSigAsm(vin.scriptSig.asm) || '',
+        sequence: vin.sequence,
+        txid: vin.txid || '',
+        vout: vin.vout || 0,
+        witness: vin.txinwitness,
+      };
+    });
+
+    if (transaction.confirmations) {
+      esploraTransaction.status = {
+        confirmed: true,
+        block_height: blocks.getCurrentBlockHeight() - transaction.confirmations + 1,
+        block_hash: transaction.blockhash,
+        block_time: transaction.blocktime,
+      };
+    }
+
+    if (transaction.confirmations) {
+      esploraTransaction = await this.$calculateFeeFromInputs(esploraTransaction, addPrevout);
+    } else {
+      esploraTransaction = await this.$appendMempoolFeeData(esploraTransaction);
+    }
+
+    return esploraTransaction;
+  }
+
+  private convertBlock(block: IBitcoinApi.Block): IEsploraApi.Block {
+    return {
+      id: block.hash,
+      height: block.height,
+      version: block.version,
+      timestamp: block.time,
+      bits: parseInt(block.bits, 16),
+      nonce: block.nonce,
+      difficulty: block.difficulty,
+      merkle_root: block.merkleroot,
+      tx_count: block.nTx,
+      size: block.size,
+      weight: block.weight,
+      previousblockhash: block.previousblockhash,
+    };
+  }
+
+  private translateScriptPubKeyType(outputType: string): string {
+    const map = {
+      'pubkey': 'p2pk',
+      'pubkeyhash': 'p2pkh',
+      'scripthash': 'p2sh',
+      'witness_v0_keyhash': 'v0_p2wpkh',
+      'witness_v0_scripthash': 'v0_p2wsh',
+      'witness_v1_taproot': 'v1_p2tr',
+      'nonstandard': 'nonstandard',
+      'nulldata': 'op_return'
+    };
+
+    if (map[outputType]) {
+      return map[outputType];
+    } else {
+      return '';
+    }
+  }
+
+  private async $appendMempoolFeeData(transaction: IEsploraApi.Transaction): Promise<IEsploraApi.Transaction> {
+    if (transaction.fee) {
+      return transaction;
+    }
+    let mempoolEntry: IBitcoinApi.MempoolEntry;
+    if (!mempool.isInSync() && !this.rawMempoolCache) {
+      this.rawMempoolCache = await this.$getRawMempoolVerbose();
+    }
+    if (this.rawMempoolCache && this.rawMempoolCache[transaction.txid]) {
+      mempoolEntry = this.rawMempoolCache[transaction.txid];
+    } else {
+      mempoolEntry = await this.$getMempoolEntry(transaction.txid);
+    }
+    transaction.fee = mempoolEntry.fees.base * 100000000;
+    return transaction;
+  }
+
+  protected async $addPrevouts(transaction: TransactionExtended): Promise<TransactionExtended> {
+    for (const vin of transaction.vin) {
+      if (vin.prevout) {
+        continue;
+      }
+      const innerTx = await this.$getRawTransaction(vin.txid, false);
+      vin.prevout = innerTx.vout[vin.vout];
+      this.addInnerScriptsToVin(vin);
+    }
+    return transaction;
+  }
+
+  protected $returnCoinbaseTransaction(): Promise<IEsploraApi.Transaction> {
+    return this.bitcoindClient.getBlock('000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f', 2)
+      .then((block: IBitcoinApi.Block) => {
+        return this.$convertTransaction(Object.assign(block.tx[0], {
+          confirmations: blocks.getCurrentBlockHeight() + 1,
+          blocktime: 1231006505 }), false);
+      });
+  }
+
+  protected $validateAddress(address: string): Promise<IBitcoinApi.AddressInformation> {
+    return this.bitcoindClient.validateAddress(address);
+  }
+
+  private $getMempoolEntry(txid: string): Promise<IBitcoinApi.MempoolEntry> {
+    return this.bitcoindClient.getMempoolEntry(txid);
+  }
+
+  private $getRawMempoolVerbose(): Promise<IBitcoinApi.RawMempool> {
+    return this.bitcoindClient.getRawMemPool(true);
+  }
+
+  private async $calculateFeeFromInputs(transaction: IEsploraApi.Transaction, addPrevout: boolean): Promise<IEsploraApi.Transaction> {
+    if (transaction.vin[0].is_coinbase) {
+      transaction.fee = 0;
+      return transaction;
+    }
+    let totalIn = 0;
+    for (const vin of transaction.vin) {
+      const innerTx = await this.$getRawTransaction(vin.txid, !addPrevout);
+      if (addPrevout) {
+        vin.prevout = innerTx.vout[vin.vout];
+        this.addInnerScriptsToVin(vin);
+      }
+      totalIn += innerTx.vout[vin.vout].value;
+    }
+    const totalOut = transaction.vout.reduce((p, output) => p + output.value, 0);
+    transaction.fee = parseFloat((totalIn - totalOut).toFixed(8));
+    return transaction;
+  }
+
+  private convertScriptSigAsm(str: string): string {
+    const a = str.split(' ');
+    const b: string[] = [];
+    a.forEach((chunk) => {
+      if (chunk.substr(0, 3) === 'OP_') {
+        chunk = chunk.replace(/^OP_(\d+)/, 'OP_PUSHNUM_$1');
+        chunk = chunk.replace('OP_CHECKSEQUENCEVERIFY', 'OP_CSV');
+        b.push(chunk);
+      } else {
+        chunk = chunk.replace('[ALL]', '01');
+        if (chunk === '0') {
+          b.push('OP_0');
+        } else {
+          b.push('OP_PUSHBYTES_' + Math.round(chunk.length / 2) + ' ' + chunk);
+        }
+      }
+    });
+    return b.join(' ');
+  }
+
+  private addInnerScriptsToVin(vin: IEsploraApi.Vin): void {
+    if (!vin.prevout) {
+      return;
+    }
+
+    if (vin.prevout.scriptpubkey_type === 'p2sh') {
+      const redeemScript = vin.scriptsig_asm.split(' ').reverse()[0];
+      vin.inner_redeemscript_asm = this.convertScriptSigAsm(bitcoinjs.script.toASM(Buffer.from(redeemScript, 'hex')));
+      if (vin.witness && vin.witness.length > 2) {
+        const witnessScript = vin.witness[vin.witness.length - 1];
+        vin.inner_witnessscript_asm = this.convertScriptSigAsm(bitcoinjs.script.toASM(Buffer.from(witnessScript, 'hex')));
+      }
+    }
+
+    if (vin.prevout.scriptpubkey_type === 'v0_p2wsh' && vin.witness) {
+      const witnessScript = vin.witness[vin.witness.length - 1];
+      vin.inner_witnessscript_asm = this.convertScriptSigAsm(bitcoinjs.script.toASM(Buffer.from(witnessScript, 'hex')));
+    }
+  }
+
+}
+
+export default BitcoinApi;

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

@@ -0,0 +1,45 @@
+import config from '../../config';
+import * as bitcoin from '@mempool/bitcoin';
+import { IBitcoinApi } from './bitcoin-api.interface';
+
+class BitcoinBaseApi {
+  bitcoindClient: any;
+  bitcoindClientMempoolInfo: any;
+
+  constructor() {
+    this.bitcoindClient = new bitcoin.Client({
+      host: config.CORE_RPC.HOST,
+      port: config.CORE_RPC.PORT,
+      user: config.CORE_RPC.USERNAME,
+      pass: config.CORE_RPC.PASSWORD,
+      timeout: 60000,
+    });
+
+    if (config.CORE_RPC_MINFEE.ENABLED) {
+      this.bitcoindClientMempoolInfo = new bitcoin.Client({
+        host: config.CORE_RPC_MINFEE.HOST,
+        port: config.CORE_RPC_MINFEE.PORT,
+        user: config.CORE_RPC_MINFEE.USERNAME,
+        pass: config.CORE_RPC_MINFEE.PASSWORD,
+        timeout: 60000,
+      });
+    }
+  }
+
+  $getMempoolInfo(): Promise<IBitcoinApi.MempoolInfo> {
+    if (config.CORE_RPC_MINFEE.ENABLED) {
+      return Promise.all([
+        this.bitcoindClient.getMempoolInfo(),
+        this.bitcoindClientMempoolInfo.getMempoolInfo()
+      ]).then(([mempoolInfo, secondMempoolInfo]) => {
+        mempoolInfo.maxmempool = secondMempoolInfo.maxmempool;
+        mempoolInfo.mempoolminfee = secondMempoolInfo.mempoolminfee;
+        mempoolInfo.minrelaytxfee = secondMempoolInfo.minrelaytxfee;
+        return mempoolInfo;
+      });
+    }
+    return this.bitcoindClient.getMempoolInfo();
+  }
+}
+
+export default new BitcoinBaseApi();

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

@@ -1,110 +0,0 @@
-const config = require('../../../mempool-config.json');
-import * as bitcoin from 'bitcoin';
-import { ITransaction, IMempoolInfo, IBlock } from '../../interfaces';
-import { AbstractBitcoinApi } from './bitcoin-api-abstract-factory';
-
-class BitcoindApi implements AbstractBitcoinApi {
-  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);
-      });
-    });
-  }
-
-  getBlockAndTransactions(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);
-      });
-    });
-  }
-
-  getBlock(hash: string): Promise<IBlock> {
-    throw new Error('Method not implemented.');
-  }
-  getBlocks(): Promise<string> {
-    throw new Error('Method not implemented.');
-  }
-  getBlocksFromHeight(height: number): Promise<string> {
-    throw new Error('Method not implemented.');
-  }
-  getBlockTransactions(hash: string): Promise<IBlock> {
-    throw new Error('Method not implemented.');
-  }
-  getBlockTransactionsFromIndex(hash: string, index: number): Promise<IBlock> {
-    throw new Error('Method not implemented.');
-  }
-  getAddress(address: string): Promise<IBlock> {
-    throw new Error('Method not implemented.');
-  }
-  getAddressTransactions(address: string): Promise<IBlock> {
-    throw new Error('Method not implemented.');
-  }
-  getAddressTransactionsFromLastSeenTxid(address: string, lastSeenTxid: string): Promise<IBlock> {
-    throw new Error('Method not implemented.');
-  }
-}
-
-export default BitcoindApi;

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

@@ -1,229 +0,0 @@
-const config = require('../../../mempool-config.json');
-import { ITransaction, IMempoolInfo, IBlock } from '../../interfaces';
-import { AbstractBitcoinApi } from './bitcoin-api-abstract-factory';
-import * as request from 'request';
-
-class ElectrsApi implements AbstractBitcoinApi {
-
-  constructor() {
-  }
-
-  getMempoolInfo(): Promise<IMempoolInfo> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/mempool', { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else {
-          resolve({
-            size: response.count,
-            bytes: response.vsize,
-          });
-        }
-      });
-    });
-  }
-
-  getRawMempool(): Promise<ITransaction['txid'][]> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/mempool/txids', { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else {
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getRawTransaction(txId: string): Promise<ITransaction> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/tx/' + txId, { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else {
-          response.vsize = Math.round(response.weight / 4);
-          response.fee = response.fee / 100000000;
-          response.blockhash = response.status.block_hash;
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getBlockCount(): Promise<number> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/blocks/tip/height', { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else {
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getBlockAndTransactions(hash: string): Promise<IBlock> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/block/' + hash, { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else {
-          request(config.ELECTRS_API_URL + '/block/' + hash + '/txids', { json: true, timeout: 10000 }, (err2, res2, response2) => {
-            if (err2) {
-              reject(err2);
-            } else if (res.statusCode !== 200) {
-              reject(response);
-            } else {
-              const block = response;
-              block.hash = hash;
-              block.nTx = block.tx_count;
-              block.time = block.timestamp;
-              block.tx = response2;
-
-              resolve(block);
-            }
-          });
-        }
-      });
-    });
-  }
-
-  getBlockHash(height: number): Promise<string> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/block-height/' + height, { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else  {
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getBlocks(): Promise<string> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/blocks', { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else  {
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getBlocksFromHeight(height: number): Promise<string> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/blocks/' + height, { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else  {
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getBlock(hash: string): Promise<IBlock> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/block/' + hash, { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else  {
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getBlockTransactions(hash: string): Promise<IBlock> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/block/' + hash + '/txs', { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else  {
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getBlockTransactionsFromIndex(hash: string, index: number): Promise<IBlock> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/block/' + hash + '/txs/' + index, { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else  {
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getAddress(address: string): Promise<IBlock> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/address/' + address, { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else  {
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getAddressTransactions(address: string): Promise<IBlock> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/address/' + address + '/txs', { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else  {
-          resolve(response);
-        }
-      });
-    });
-  }
-
-  getAddressTransactionsFromLastSeenTxid(address: string, lastSeenTxid: string): Promise<IBlock> {
-    return new Promise((resolve, reject) => {
-      request(config.ELECTRS_API_URL + '/address/' + address + '/txs/chain/' + lastSeenTxid,
-        { json: true, timeout: 10000 }, (err, res, response) => {
-        if (err) {
-          reject(err);
-        } else if (res.statusCode !== 200) {
-          reject(response);
-        } else  {
-          resolve(response);
-        }
-      });
-    });
-  }
-}
-
-export default ElectrsApi;

backend/src/api/bitcoin/electrum-api.interface.ts

@@ -0,0 +1,12 @@
+export namespace IElectrumApi {
+  export interface ScriptHashBalance {
+    confirmed: number;
+    unconfirmed: number;
+  }
+
+  export interface ScriptHashHistory {
+    height: number;
+    tx_hash: string;
+    fee?: number;
+  }
+}

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

@@ -0,0 +1,161 @@
+import config from '../../config';
+import { AbstractBitcoinApi } from './bitcoin-api-abstract-factory';
+import { IBitcoinApi } from './bitcoin-api.interface';
+import { IEsploraApi } from './esplora-api.interface';
+import { IElectrumApi } from './electrum-api.interface';
+import BitcoinApi from './bitcoin-api';
+import mempool from '../mempool';
+import logger from '../../logger';
+import * as ElectrumClient from '@mempool/electrum-client';
+import * as sha256 from 'crypto-js/sha256';
+import * as hexEnc from 'crypto-js/enc-hex';
+import loadingIndicators from '../loading-indicators';
+import memoryCache from '../memory-cache';
+
+class BitcoindElectrsApi extends BitcoinApi implements AbstractBitcoinApi {
+  private electrumClient: any;
+
+  constructor() {
+    super();
+
+    const electrumConfig = { client: 'mempool-v2', version: '1.4' };
+    const electrumPersistencePolicy = { retryPeriod: 10000, maxRetry: 1000, callback: null };
+
+    const electrumCallbacks = {
+      onConnect: (client, versionInfo) => { logger.info(`Connected to Electrum Server at ${config.ELECTRUM.HOST}:${config.ELECTRUM.PORT} (${JSON.stringify(versionInfo)})`); },
+      onClose: (client) => { logger.info(`Disconnected from Electrum Server at ${config.ELECTRUM.HOST}:${config.ELECTRUM.PORT}`); },
+      onError: (err) => { logger.err(`Electrum error: ${JSON.stringify(err)}`); },
+      onLog: (str) => { logger.debug(str); },
+    };
+
+    this.electrumClient = new ElectrumClient(
+      config.ELECTRUM.PORT,
+      config.ELECTRUM.HOST,
+      config.ELECTRUM.TLS_ENABLED ? 'tls' : 'tcp',
+      null,
+      electrumCallbacks
+    );
+
+    this.electrumClient.initElectrum(electrumConfig, electrumPersistencePolicy)
+      .then(() => {})
+      .catch((err) => {
+        logger.err(`Error connecting to Electrum Server at ${config.ELECTRUM.HOST}:${config.ELECTRUM.PORT}`);
+      });
+  }
+
+  async $getAddress(address: string): Promise<IEsploraApi.Address> {
+    const addressInfo = await this.$validateAddress(address);
+    if (!addressInfo || !addressInfo.isvalid) {
+      return ({
+        'address': address,
+        'chain_stats': {
+          'funded_txo_count': 0,
+          'funded_txo_sum': 0,
+          'spent_txo_count': 0,
+          'spent_txo_sum': 0,
+          'tx_count': 0
+        },
+        'mempool_stats': {
+          'funded_txo_count': 0,
+          'funded_txo_sum': 0,
+          'spent_txo_count': 0,
+          'spent_txo_sum': 0,
+          'tx_count': 0
+        }
+      });
+    }
+
+    try {
+      const balance = await this.$getScriptHashBalance(addressInfo.scriptPubKey);
+      const history = await this.$getScriptHashHistory(addressInfo.scriptPubKey);
+
+      const unconfirmed = history.filter((h) => h.fee).length;
+
+      return {
+        'address': addressInfo.address,
+        'chain_stats': {
+          'funded_txo_count': 0,
+          'funded_txo_sum': balance.confirmed ? balance.confirmed : 0,
+          'spent_txo_count': 0,
+          'spent_txo_sum': balance.confirmed < 0 ? balance.confirmed : 0,
+          'tx_count': history.length - unconfirmed,
+        },
+        'mempool_stats': {
+          'funded_txo_count': 0,
+          'funded_txo_sum': balance.unconfirmed > 0 ? balance.unconfirmed : 0,
+          'spent_txo_count': 0,
+          'spent_txo_sum': balance.unconfirmed < 0 ? -balance.unconfirmed : 0,
+          'tx_count': unconfirmed,
+        },
+        'electrum': true,
+      };
+    } catch (e) {
+      if (e === 'failed to get confirmed status') {
+        e = 'The number of transactions on this address exceeds the Electrum server limit';
+      }
+      throw new Error(e);
+    }
+  }
+
+  async $getAddressTransactions(address: string, lastSeenTxId: string): Promise<IEsploraApi.Transaction[]> {
+    const addressInfo = await this.$validateAddress(address);
+    if (!addressInfo || !addressInfo.isvalid) {
+     return [];
+    }
+
+    try {
+      loadingIndicators.setProgress('address-' + address, 0);
+
+      const transactions: IEsploraApi.Transaction[] = [];
+      const history = await this.$getScriptHashHistory(addressInfo.scriptPubKey);
+      history.sort((a, b) => (b.height || 9999999) - (a.height || 9999999));
+
+      let startingIndex = 0;
+      if (lastSeenTxId) {
+        const pos = history.findIndex((historicalTx) => historicalTx.tx_hash === lastSeenTxId);
+        if (pos) {
+          startingIndex = pos + 1;
+        }
+      }
+      const endIndex = Math.min(startingIndex + 10, history.length);
+
+      for (let i = startingIndex; i < endIndex; i++) {
+        const tx = await this.$getRawTransaction(history[i].tx_hash, false, true);
+        transactions.push(tx);
+        loadingIndicators.setProgress('address-' + address, (i + 1) / endIndex * 100);
+      }
+
+      return transactions;
+    } catch (e) {
+      loadingIndicators.setProgress('address-' + address, 100);
+      if (e === 'failed to get confirmed status') {
+        e = 'The number of transactions on this address exceeds the Electrum server limit';
+      }
+      throw new Error(e);
+    }
+  }
+
+  private $getScriptHashBalance(scriptHash: string): Promise<IElectrumApi.ScriptHashBalance> {
+    return this.electrumClient.blockchainScripthash_getBalance(this.encodeScriptHash(scriptHash));
+  }
+
+  private $getScriptHashHistory(scriptHash: string): Promise<IElectrumApi.ScriptHashHistory[]> {
+    const fromCache = memoryCache.get<IElectrumApi.ScriptHashHistory[]>('Scripthash_getHistory', scriptHash);
+    if (fromCache) {
+      return Promise.resolve(fromCache);
+    }
+    return this.electrumClient.blockchainScripthash_getHistory(this.encodeScriptHash(scriptHash))
+      .then((history) => {
+        memoryCache.set('Scripthash_getHistory', scriptHash, history, 2);
+        return history;
+      });
+  }
+
+  private encodeScriptHash(scriptPubKey: string): string {
+    const addrScripthash = hexEnc.stringify(sha256(hexEnc.parse(scriptPubKey)));
+    return addrScripthash.match(/.{2}/g).reverse().join('');
+  }
+
+}
+
+export default BitcoindElectrsApi;

backend/src/api/bitcoin/esplora-api.interface.ts

@@ -0,0 +1,169 @@
+export namespace IEsploraApi {
+  export interface Transaction {
+    txid: string;
+    version: number;
+    locktime: number;
+    size: number;
+    weight: number;
+    fee: number;
+    vin: Vin[];
+    vout: Vout[];
+    status: Status;
+  }
+
+  export interface Recent {
+    txid: string;
+    fee: number;
+    vsize: number;
+    value: number;
+  }
+
+  export interface Vin {
+    txid: string;
+    vout: number;
+    is_coinbase: boolean;
+    scriptsig: string;
+    scriptsig_asm: string;
+    inner_redeemscript_asm?: string;
+    inner_witnessscript_asm?: string;
+    sequence: any;
+    witness?: string[];
+    prevout: Vout | null;
+    // Elements
+    is_pegin?: boolean;
+    issuance?: Issuance;
+  }
+
+  interface Issuance {
+    asset_id: string;
+    is_reissuance: string;
+    asset_blinding_nonce: string;
+    asset_entropy: string;
+    contract_hash: string;
+    assetamount?: number;
+    assetamountcommitment?: string;
+    tokenamount?: number;
+    tokenamountcommitment?: string;
+  }
+
+  export interface Vout {
+    scriptpubkey: string;
+    scriptpubkey_asm: string;
+    scriptpubkey_type: string;
+    scriptpubkey_address: string;
+    value: number;
+    // Elements
+    valuecommitment?: number;
+    asset?: string;
+    pegout?: Pegout;
+  }
+
+  interface Pegout {
+    genesis_hash: string;
+    scriptpubkey: string;
+    scriptpubkey_asm: string;
+    scriptpubkey_address: string;
+  }
+
+  export interface Status {
+    confirmed: boolean;
+    block_height?: number;
+    block_hash?: string;
+    block_time?: number;
+  }
+
+  export interface Block {
+    id: string;
+    height: number;
+    version: number;
+    timestamp: number;
+    bits: number;
+    nonce: number;
+    difficulty: number;
+    merkle_root: string;
+    tx_count: number;
+    size: number;
+    weight: number;
+    previousblockhash: string;
+  }
+
+  export interface Address {
+    address: string;
+    chain_stats: ChainStats;
+    mempool_stats: MempoolStats;
+    electrum?: boolean;
+  }
+
+  export interface ChainStats {
+    funded_txo_count: number;
+    funded_txo_sum: number;
+    spent_txo_count: number;
+    spent_txo_sum: number;
+    tx_count: number;
+  }
+
+  export interface MempoolStats {
+    funded_txo_count: number;
+    funded_txo_sum: number;
+    spent_txo_count: number;
+    spent_txo_sum: number;
+    tx_count: number;
+  }
+
+  export interface Outspend {
+    spent: boolean;
+    txid: string;
+    vin: number;
+    status: Status;
+  }
+
+  export interface Asset {
+    asset_id: string;
+    issuance_txin: IssuanceTxin;
+    issuance_prevout: IssuancePrevout;
+    reissuance_token: string;
+    contract_hash: string;
+    status: Status;
+    chain_stats: AssetStats;
+    mempool_stats: AssetStats;
+  }
+
+  export interface AssetExtended extends Asset {
+    name: string;
+    ticker: string;
+    precision: number;
+    entity: Entity;
+    version: number;
+    issuer_pubkey: string;
+  }
+
+  export interface Entity {
+    domain: string;
+  }
+
+  interface IssuanceTxin {
+    txid: string;
+    vin: number;
+  }
+
+  interface IssuancePrevout {
+    txid: string;
+    vout: number;
+  }
+
+  interface AssetStats {
+    tx_count: number;
+    issuance_count: number;
+    issued_amount: number;
+    burned_amount: number;
+    has_blinded_issuances: boolean;
+    reissuance_tokens: number;
+    burned_reissuance_tokens: number;
+    peg_in_count: number;
+    peg_in_amount: number;
+    peg_out_count: number;
+    peg_out_amount: number;
+    burn_count: number;
+  }
+
+}

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

@@ -0,0 +1,61 @@
+import config from '../../config';
+import axios, { AxiosRequestConfig } from 'axios';
+import { AbstractBitcoinApi } from './bitcoin-api-abstract-factory';
+import { IEsploraApi } from './esplora-api.interface';
+
+class ElectrsApi implements AbstractBitcoinApi {
+  axiosConfig: AxiosRequestConfig = {
+    timeout: 10000,
+  };
+
+  constructor() { }
+
+  $getRawMempool(): Promise<IEsploraApi.Transaction['txid'][]> {
+    return axios.get<IEsploraApi.Transaction['txid'][]>(config.ESPLORA.REST_API_URL + '/mempool/txids', this.axiosConfig)
+      .then((response) => response.data);
+  }
+
+  $getRawTransaction(txId: string): Promise<IEsploraApi.Transaction> {
+    return axios.get<IEsploraApi.Transaction>(config.ESPLORA.REST_API_URL + '/tx/' + txId, this.axiosConfig)
+      .then((response) => response.data);
+  }
+
+  $getBlockHeightTip(): Promise<number> {
+    return axios.get<number>(config.ESPLORA.REST_API_URL + '/blocks/tip/height', this.axiosConfig)
+      .then((response) => response.data);
+  }
+
+  $getTxIdsForBlock(hash: string): Promise<string[]> {
+    return axios.get<string[]>(config.ESPLORA.REST_API_URL + '/block/' + hash + '/txids', this.axiosConfig)
+      .then((response) => response.data);
+  }
+
+  $getBlockHash(height: number): Promise<string> {
+    return axios.get<string>(config.ESPLORA.REST_API_URL + '/block-height/' + height, this.axiosConfig)
+      .then((response) => response.data);
+  }
+
+  $getBlock(hash: string): Promise<IEsploraApi.Block> {
+    return axios.get<IEsploraApi.Block>(config.ESPLORA.REST_API_URL + '/block/' + hash, this.axiosConfig)
+      .then((response) => response.data);
+  }
+
+  $getAddress(address: string): Promise<IEsploraApi.Address> {
+    throw new Error('Method getAddress not implemented.');
+  }
+
+  $getAddressTransactions(address: string, txId?: string): Promise<IEsploraApi.Transaction[]> {
+    throw new Error('Method getAddressTransactions not implemented.');
+  }
+
+  $getRawTransactionBitcoind(txId: string): Promise<IEsploraApi.Transaction> {
+    return axios.get<IEsploraApi.Transaction>(config.ESPLORA.REST_API_URL + '/tx/' + txId, this.axiosConfig)
+      .then((response) => response.data);
+  }
+
+  $getAddressPrefix(prefix: string): string[] {
+    throw new Error('Method not implemented.');
+  }
+}
+
+export default ElectrsApi;

backend/src/api/blocks.ts

@@ -1,214 +1,122 @@
-const config = require('../../mempool-config.json');
+import config from '../config';
 import bitcoinApi from './bitcoin/bitcoin-api-factory';
-import { DB } from '../database';
-import { IBlock, ITransaction } from '../interfaces';
+import logger from '../logger';
 import memPool from './mempool';
+import { BlockExtended, TransactionExtended } from '../mempool.interfaces';
+import { Common } from './common';
+import diskCache from './disk-cache';
+import transactionUtils from './transaction-utils';
 
 class Blocks {
-  private blocks: IBlock[] = [];
-  private newBlockCallback: Function | undefined;
+  private static INITIAL_BLOCK_AMOUNT = 8;
+  private blocks: BlockExtended[] = [];
   private currentBlockHeight = 0;
+  private lastDifficultyAdjustmentTime = 0;
+  private newBlockCallbacks: ((block: BlockExtended, txIds: string[], transactions: TransactionExtended[]) => void)[] = [];
 
-  constructor() {
-    setInterval(this.$clearOldTransactionsAndBlocksFromDatabase.bind(this), 86400000);
-  }
+  constructor() { }
 
-  public setNewBlockCallback(fn: Function) {
-    this.newBlockCallback = fn;
-  }
-
-  public getBlocks(): IBlock[] {
+  public getBlocks(): BlockExtended[] {
     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 setBlocks(blocks: BlockExtended[]) {
+    this.blocks = blocks;
   }
 
-  public async updateBlocks() {
-    try {
-      const blockCount = await bitcoinApi.getBlockCount();
+  public setNewBlockCallback(fn: (block: BlockExtended, txIds: string[], transactions: TransactionExtended[]) => void) {
+    this.newBlockCallbacks.push(fn);
+  }
 
-      if (this.blocks.length === 0) {
-        this.currentBlockHeight = blockCount - config.INITIAL_BLOCK_AMOUNT;
+  public async $updateBlocks() {
+    const blockHeightTip = await bitcoinApi.$getBlockHeightTip();
+
+    if (this.blocks.length === 0) {
+      this.currentBlockHeight = blockHeightTip - Blocks.INITIAL_BLOCK_AMOUNT;
+    } else {
+      this.currentBlockHeight = this.blocks[this.blocks.length - 1].height;
+    }
+
+    if (blockHeightTip - this.currentBlockHeight > Blocks.INITIAL_BLOCK_AMOUNT * 2) {
+      logger.info(`${blockHeightTip - this.currentBlockHeight} blocks since tip. Fast forwarding to the ${Blocks.INITIAL_BLOCK_AMOUNT} recent blocks`);
+      this.currentBlockHeight = blockHeightTip - Blocks.INITIAL_BLOCK_AMOUNT;
+    }
+
+    if (!this.lastDifficultyAdjustmentTime) {
+      const heightDiff = blockHeightTip % 2016;
+      const blockHash = await bitcoinApi.$getBlockHash(blockHeightTip - heightDiff);
+      const block = await bitcoinApi.$getBlock(blockHash);
+      this.lastDifficultyAdjustmentTime = block.timestamp;
+    }
+
+    while (this.currentBlockHeight < blockHeightTip) {
+      if (this.currentBlockHeight === 0) {
+        this.currentBlockHeight = blockHeightTip;
       } else {
-        this.currentBlockHeight = this.blocks[this.blocks.length - 1].height;
+        this.currentBlockHeight++;
+        logger.debug(`New block found (#${this.currentBlockHeight})!`);
       }
 
-      while (this.currentBlockHeight < blockCount) {
-        this.currentBlockHeight++;
+      const transactions: TransactionExtended[] = [];
 
-        let block: IBlock | undefined;
+      const blockHash = await bitcoinApi.$getBlockHash(this.currentBlockHeight);
+      const block = await bitcoinApi.$getBlock(blockHash);
+      const txIds: string[] = await bitcoinApi.$getTxIdsForBlock(blockHash);
 
-        const storedBlock = await this.$getBlockFromDatabase(this.currentBlockHeight);
-        if (storedBlock) {
-          block = storedBlock;
-        } else {
-          const blockHash = await bitcoinApi.getBlockHash(this.currentBlockHeight);
-          block = await bitcoinApi.getBlockAndTransactions(blockHash);
+      const mempool = memPool.getMempool();
+      let transactionsFound = 0;
 
-          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 {
-              console.log(`Fetching block tx ${i} of ${block.tx.length}`);
-              const tx = await memPool.getRawTransaction(block.tx[i]);
-              if (tx) {
-                transactions.push(tx);
-              }
-              notFound++;
+      for (let i = 0; i < txIds.length; i++) {
+        if (mempool[txIds[i]]) {
+          transactions.push(mempool[txIds[i]]);
+          transactionsFound++;
+        } else if (config.MEMPOOL.BACKEND === 'esplora' || memPool.isInSync() || i === 0) {
+          logger.debug(`Fetching block tx ${i} of ${txIds.length}`);
+          try {
+            const tx = await transactionUtils.$getTransactionExtended(txIds[i]);
+            transactions.push(tx);
+          } catch (e) {
+            logger.debug('Error fetching block tx: ' + e.message || e);
+            if (i === 0) {
+              throw new Error('Failed to fetch Coinbase transaction: ' + txIds[i]);
             }
           }
-
-          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));
-
-          console.log(`New block found (#${this.currentBlockHeight})! `
-           + `${found} of ${block.tx.length} found in mempool. ${notFound} not found.`);
-
-           if (this.newBlockCallback) {
-            this.newBlockCallback(block);
-          }
-
-          this.$saveBlockToDatabase(block);
-          this.$saveTransactionsToDatabase(block.height, transactions);
         }
-
-        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);
+      logger.debug(`${transactionsFound} of ${txIds.length} found in mempool. ${txIds.length - transactionsFound} not found.`);
+
+      const blockExtended: BlockExtended = Object.assign({}, block);
+      blockExtended.reward = transactions[0].vout.reduce((acc, curr) => acc + curr.value, 0);
+      blockExtended.coinbaseTx = transactionUtils.stripCoinbaseTransaction(transactions[0]);
+      transactions.sort((a, b) => b.feePerVsize - a.feePerVsize);
+      blockExtended.medianFee = transactions.length > 1 ? Common.median(transactions.map((tx) => tx.feePerVsize)) : 0;
+      blockExtended.feeRange = transactions.length > 1 ? Common.getFeesInRange(transactions.slice(0, transactions.length - 1), 8) : [0, 0];
+
+      if (block.height % 2016 === 0) {
+        this.lastDifficultyAdjustmentTime = block.timestamp;
+      }
+
+      this.blocks.push(blockExtended);
+      if (this.blocks.length > Blocks.INITIAL_BLOCK_AMOUNT * 4) {
+        this.blocks = this.blocks.slice(-Blocks.INITIAL_BLOCK_AMOUNT * 4);
+      }
+
+      if (this.newBlockCallbacks.length) {
+        this.newBlockCallbacks.forEach((cb) => cb(blockExtended, txIds, transactions));
+      }
+      if (memPool.isInSync()) {
+        diskCache.$saveCacheToDisk();
+      }
     }
   }
 
-  private async $clearOldTransactionsAndBlocksFromDatabase() {
-    try {
-      const connection = await DB.pool.getConnection();
-      let query = `DELETE FROM blocks WHERE height < ?`;
-      await connection.query<any>(query, [this.currentBlockHeight - config.KEEP_BLOCK_AMOUNT]);
-      query = `DELETE FROM transactions WHERE blockheight < ?`;
-      await connection.query<any>(query, [this.currentBlockHeight - config.KEEP_BLOCK_AMOUNT]);
-      connection.release();
-    } catch (e) {
-      console.log('$clearOldTransactionsFromDatabase() error', e);
-    }
+  public getLastDifficultyAdjustmentTime(): number {
+    return this.lastDifficultyAdjustmentTime;
   }
 
-  private median(numbers: number[]) {
-    if (!numbers.length) { return 0; }
-    let medianNr = 0;
-    const numsLen = numbers.length;
-    if (numsLen % 2 === 0) {
-        medianNr = (numbers[numsLen / 2 - 1] + numbers[numsLen / 2]) / 2;
-    } else {
-        medianNr = numbers[(numsLen - 1) / 2];
-    }
-    return medianNr;
+  public getCurrentBlockHeight(): number {
+    return this.currentBlockHeight;
   }
 }
 

backend/src/api/common.ts

@@ -0,0 +1,67 @@
+import { TransactionExtended, TransactionStripped } from '../mempool.interfaces';
+
+export class Common {
+  static median(numbers: number[]) {
+    let medianNr = 0;
+    const numsLen = numbers.length;
+    if (numsLen % 2 === 0) {
+        medianNr = (numbers[numsLen / 2 - 1] + numbers[numsLen / 2]) / 2;
+    } else {
+        medianNr = numbers[(numsLen - 1) / 2];
+    }
+    return medianNr;
+  }
+
+  static getFeesInRange(transactions: TransactionExtended[], rangeLength: number) {
+    const arr = [transactions[transactions.length - 1].feePerVsize];
+    const chunk = 1 / (rangeLength - 1);
+    let itemsToAdd = rangeLength - 2;
+
+    while (itemsToAdd > 0) {
+      arr.push(transactions[Math.floor(transactions.length * chunk * itemsToAdd)].feePerVsize);
+      itemsToAdd--;
+    }
+
+    arr.push(transactions[0].feePerVsize);
+    return arr;
+  }
+
+  static findRbfTransactions(added: TransactionExtended[], deleted: TransactionExtended[]): { [txid: string]: TransactionExtended } {
+    const matches: { [txid: string]: TransactionExtended } = {};
+    deleted
+      // The replaced tx must have at least one input with nSequence < maxint-1 (That’s the opt-in)
+      .filter((tx) => tx.vin.some((vin) => vin.sequence < 0xfffffffe))
+      .forEach((deletedTx) => {
+        const foundMatches = added.find((addedTx) => {
+          // The new tx must, absolutely speaking, pay at least as much fee as the replaced tx.
+          return addedTx.fee > deletedTx.fee
+            // The new transaction must pay more fee per kB than the replaced tx.
+            && addedTx.feePerVsize > deletedTx.feePerVsize
+            // Spends one or more of the same inputs
+            && deletedTx.vin.some((deletedVin) =>
+              addedTx.vin.some((vin) => vin.txid === deletedVin.txid));
+            });
+        if (foundMatches) {
+          matches[deletedTx.txid] = foundMatches;
+        }
+      });
+    return matches;
+  }
+
+  static stripTransaction(tx: TransactionExtended): TransactionStripped {
+    return {
+      txid: tx.txid,
+      fee: tx.fee,
+      vsize: tx.weight / 4,
+      value: tx.vout.reduce((acc, vout) => acc + (vout.value ? vout.value : 0), 0),
+    };
+  }
+
+  static sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => {
+       setTimeout(() => {
+         resolve();
+       }, ms);
+    });
+  }
+}

backend/src/api/disk-cache.ts

@@ -1,15 +1,87 @@
 import * as fs from 'fs';
+const fsPromises = fs.promises;
+import * as cluster from 'cluster';
+import memPool from './mempool';
+import blocks from './blocks';
+import logger from '../logger';
+import config from '../config';
+import { TransactionExtended } from '../mempool.interfaces';
 
 class DiskCache {
-  static FILE_NAME = './cache.json';
+  private static FILE_NAME = config.MEMPOOL.CACHE_DIR + '/cache.json';
+  private static FILE_NAMES = config.MEMPOOL.CACHE_DIR + '/cache{number}.json';
+  private static CHUNK_FILES = 25;
+
   constructor() { }
 
-  saveData(dataBlob: string) {
-    fs.writeFileSync(DiskCache.FILE_NAME, dataBlob, 'utf8');
+  async $saveCacheToDisk(): Promise<void> {
+    if (!cluster.isMaster) {
+      return;
+    }
+    try {
+      logger.debug('Writing mempool and blocks data to disk cache (async)...');
+
+      const mempool = memPool.getMempool();
+      const mempoolArray: TransactionExtended[] = [];
+      for (const tx in mempool) {
+        mempoolArray.push(mempool[tx]);
+      }
+
+      const chunkSize = Math.floor(mempoolArray.length / DiskCache.CHUNK_FILES);
+
+      await fsPromises.writeFile(DiskCache.FILE_NAME, JSON.stringify({
+        blocks: blocks.getBlocks(),
+        mempool: {},
+        mempoolArray: mempoolArray.splice(0, chunkSize),
+      }), {flag: 'w'});
+      for (let i = 1; i < DiskCache.CHUNK_FILES; i++) {
+        await fsPromises.writeFile(DiskCache.FILE_NAMES.replace('{number}', i.toString()), JSON.stringify({
+          mempool: {},
+          mempoolArray: mempoolArray.splice(0, chunkSize),
+        }), {flag: 'w'});
+      }
+      logger.debug('Mempool and blocks data saved to disk cache');
+    } catch (e) {
+      logger.warn('Error writing to cache file: ' + e.message || e);
+    }
   }
 
-  loadData(): string {
-    return fs.readFileSync(DiskCache.FILE_NAME, 'utf8');
+  loadMempoolCache() {
+    if (!fs.existsSync(DiskCache.FILE_NAME)) {
+      return;
+    }
+    try {
+      let data: any = {};
+      const cacheData = fs.readFileSync(DiskCache.FILE_NAME, 'utf8');
+      if (cacheData) {
+        logger.info('Restoring mempool and blocks data from disk cache');
+        data = JSON.parse(cacheData);
+        if (data.mempoolArray) {
+          for (const tx of data.mempoolArray) {
+            data.mempool[tx.txid] = tx;
+          }
+        }
+      }
+
+      for (let i = 1; i < DiskCache.CHUNK_FILES; i++) {
+        const fileName = DiskCache.FILE_NAMES.replace('{number}', i.toString());
+        if (fs.existsSync(fileName)) {
+          const cacheData2 = JSON.parse(fs.readFileSync(fileName, 'utf8'));
+          if (cacheData2.mempoolArray) {
+            for (const tx of cacheData2.mempoolArray) {
+              data.mempool[tx.txid] = tx;
+            }
+          } else {
+            Object.assign(data.mempool, cacheData2.mempool);
+          }
+        }
+      }
+
+      memPool.setMempool(data.mempool);
+      blocks.setBlocks(data.blocks);
+    } catch (e) {
+      logger.warn('Failed to parse mempoool and blocks cache. Skipping...');
+    }
   }
 }
 

backend/src/api/fee-api.ts

@@ -1,26 +1,26 @@
-import projectedBlocks from './projected-blocks';
-import { DB } from '../database';
+import config from '../config';
+import { MempoolBlock } from '../mempool.interfaces';
+import projectedBlocks from './mempool-blocks';
 
 class FeeApi {
   constructor() { }
 
+  defaultFee = config.MEMPOOL.NETWORK === 'liquid' ? 0.1 : 1;
+
   public getRecommendedFee() {
-    const pBlocks = projectedBlocks.getProjectedBlocks();
+    const pBlocks = projectedBlocks.getMempoolBlocks();
+
     if (!pBlocks.length) {
       return {
-        'fastestFee': 0,
-        'halfHourFee': 0,
-        'hourFee': 0,
+        'fastestFee': this.defaultFee,
+        'halfHourFee': this.defaultFee,
+        'hourFee': this.defaultFee,
       };
     }
-    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;
+    const firstMedianFee = this.optimizeMedianFee(pBlocks[0], pBlocks[1]);
+    const secondMedianFee = pBlocks[1] ? this.optimizeMedianFee(pBlocks[1], pBlocks[2], firstMedianFee) : this.defaultFee;
+    const thirdMedianFee = pBlocks[2] ? this.optimizeMedianFee(pBlocks[2], pBlocks[3], secondMedianFee) : this.defaultFee;
 
     return {
       'fastestFee': firstMedianFee,
@@ -29,19 +29,17 @@ class FeeApi {
     };
   }
 
-  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 [];
+  private optimizeMedianFee(pBlock: MempoolBlock, nextBlock: MempoolBlock | undefined, previousFee?: number): number {
+    const useFee = previousFee ? (pBlock.medianFee + previousFee) / 2 : pBlock.medianFee;
+    if (pBlock.blockVSize <= 500000) {
+      return this.defaultFee;
     }
+    if (pBlock.blockVSize <= 950000 && nextBlock) {
+      const multiplier = (pBlock.blockVSize - 500000) / 500000;
+      return Math.max(Math.round(useFee * multiplier), this.defaultFee);
+    }
+    return Math.round(useFee);
   }
-
 }
 
 export default new FeeApi();

backend/src/api/fiat-conversion.ts

@@ -1,30 +1,42 @@
-import * as request from 'request';
+import logger from '../logger';
+import axios from 'axios';
+import { IConversionRates } from '../mempool.interfaces';
 
 class FiatConversion {
-  private tickers = {
-    'BTCUSD': {
-      'USD': 4110.78
-    },
+  private conversionRates: IConversionRates = {
+    'USD': 0
   };
+  private ratesChangedCallback: ((rates: IConversionRates) => void) | undefined;
 
   constructor() { }
 
+  public setProgressChangedCallback(fn: (rates: IConversionRates) => void) {
+    this.ratesChangedCallback = fn;
+  }
+
   public startService() {
+    logger.info('Starting currency rates service');
     setInterval(this.updateCurrency.bind(this), 1000 * 60 * 60);
     this.updateCurrency();
   }
 
-  public getTickers() {
-    return this.tickers;
+  public getConversionRates() {
+    return this.conversionRates;
   }
 
-  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;
+  private async updateCurrency(): Promise<void> {
+    try {
+      const response = await axios.get('https://price.bisq.wiz.biz/getAllMarketPrices', { timeout: 10000 });
+      const usd = response.data.data.find((item: any) => item.currencyCode === 'USD');
+      this.conversionRates = {
+        'USD': usd.price,
+      };
+      if (this.ratesChangedCallback) {
+        this.ratesChangedCallback(this.conversionRates);
       }
-    });
+    } catch (e) {
+      logger.err('Error updating fiat conversion rates: ' + e);
+    }
   }
 }
 

backend/src/api/loading-indicators.ts

@@ -0,0 +1,32 @@
+import { ILoadingIndicators } from '../mempool.interfaces';
+
+class LoadingIndicators {
+  private loadingIndicators: ILoadingIndicators = {
+    'mempool': 0,
+  };
+  private progressChangedCallback: ((loadingIndicators: ILoadingIndicators) => void) | undefined;
+
+  constructor() { }
+
+  public setProgressChangedCallback(fn: (loadingIndicators: ILoadingIndicators) => void) {
+    this.progressChangedCallback = fn;
+  }
+
+  public setProgress(name: string, progressPercent: number) {
+    const newProgress = Math.round(progressPercent);
+    if (newProgress >= 100) {
+      delete this.loadingIndicators[name];
+    } else {
+      this.loadingIndicators[name] = newProgress;
+    }
+    if (this.progressChangedCallback) {
+      this.progressChangedCallback(this.loadingIndicators);
+    }
+  }
+
+  public getLoadingIndicators() {
+    return this.loadingIndicators;
+  }
+}
+
+export default new LoadingIndicators();

backend/src/api/memory-cache.ts

@@ -0,0 +1,38 @@
+interface ICache {
+  type: string;
+  id: string;
+  expires: Date;
+  data: any;
+}
+
+class MemoryCache {
+  private cache: ICache[] = [];
+  constructor() {
+    setInterval(this.cleanup.bind(this), 1000);
+  }
+
+  public set(type: string, id: string, data: any, secondsExpiry: number) {
+    const expiry = new Date();
+    expiry.setSeconds(expiry.getSeconds() + secondsExpiry);
+    this.cache.push({
+      type: type,
+      id: id,
+      data: data,
+      expires: expiry,
+    });
+  }
+
+  public get<T>(type: string, id: string): T | null {
+    const found = this.cache.find((cache) => cache.type === type && cache.id === id);
+    if (found) {
+      return found.data;
+    }
+    return null;
+  }
+
+  private cleanup() {
+    this.cache = this.cache.filter((cache) => cache.expires < (new Date()));
+  }
+}
+
+export default new MemoryCache();

backend/src/api/mempool-blocks.ts

@@ -0,0 +1,86 @@
+import { MempoolBlock, TransactionExtended, MempoolBlockWithTransactions } from '../mempool.interfaces';
+import { Common } from './common';
+
+class MempoolBlocks {
+  private static DEFAULT_PROJECTED_BLOCKS_AMOUNT = 8;
+  private mempoolBlocks: MempoolBlockWithTransactions[] = [];
+
+  constructor() {}
+
+  public getMempoolBlocks(): MempoolBlock[] {
+    return this.mempoolBlocks.map((block) => {
+      return {
+        blockSize: block.blockSize,
+        blockVSize: block.blockVSize,
+        nTx: block.nTx,
+        totalFees: block.totalFees,
+        medianFee: block.medianFee,
+        feeRange: block.feeRange,
+      };
+    });
+  }
+
+  public getMempoolBlocksWithTransactions(): MempoolBlockWithTransactions[] {
+    return this.mempoolBlocks;
+  }
+
+  public updateMempoolBlocks(memPool: { [txid: string]: TransactionExtended }): void {
+    const latestMempool = memPool;
+    const memPoolArray: TransactionExtended[] = [];
+    for (const i in latestMempool) {
+      if (latestMempool.hasOwnProperty(i)) {
+        memPoolArray.push(latestMempool[i]);
+      }
+    }
+    memPoolArray.sort((a, b) => b.feePerVsize - a.feePerVsize);
+    const transactionsSorted = memPoolArray.filter((tx) => tx.feePerVsize);
+    this.mempoolBlocks = this.calculateMempoolBlocks(transactionsSorted);
+  }
+
+  private calculateMempoolBlocks(transactionsSorted: TransactionExtended[]): MempoolBlockWithTransactions[] {
+    const mempoolBlocks: MempoolBlockWithTransactions[] = [];
+    let blockVSize = 0;
+    let blockSize = 0;
+    let transactions: TransactionExtended[] = [];
+    transactionsSorted.forEach((tx) => {
+      if (blockVSize + tx.vsize <= 1000000 || mempoolBlocks.length === MempoolBlocks.DEFAULT_PROJECTED_BLOCKS_AMOUNT - 1) {
+        blockVSize += tx.vsize;
+        blockSize += tx.size;
+        transactions.push(tx);
+      } else {
+        mempoolBlocks.push(this.dataToMempoolBlocks(transactions, blockSize, blockVSize, mempoolBlocks.length));
+        blockVSize = tx.vsize;
+        blockSize = tx.size;
+        transactions = [tx];
+      }
+    });
+    if (transactions.length) {
+      mempoolBlocks.push(this.dataToMempoolBlocks(transactions, blockSize, blockVSize, mempoolBlocks.length));
+    }
+    return mempoolBlocks;
+  }
+
+  private dataToMempoolBlocks(transactions: TransactionExtended[],
+    blockSize: number, blockVSize: number, blocksIndex: number): MempoolBlockWithTransactions {
+    let rangeLength = 4;
+    if (blocksIndex === 0) {
+      rangeLength = 8;
+    }
+    if (transactions.length > 4000) {
+      rangeLength = 6;
+    } else if (transactions.length > 10000) {
+      rangeLength = 8;
+    }
+    return {
+      blockSize: blockSize,
+      blockVSize: blockVSize,
+      nTx: transactions.length,
+      totalFees: transactions.reduce((acc, cur) => acc + cur.fee, 0),
+      medianFee: Common.median(transactions.map((tx) => tx.feePerVsize)),
+      feeRange: Common.getFeesInRange(transactions, rangeLength),
+      transactionIds: transactions.map((tx) => tx.txid),
+    };
+  }
+}
+
+export default new MempoolBlocks();

backend/src/api/mempool.ts

@@ -1,35 +1,68 @@
-const config = require('../../mempool-config.json');
+import config from '../config';
 import bitcoinApi from './bitcoin/bitcoin-api-factory';
-import { ITransaction, IMempoolInfo, IMempool } from '../interfaces';
+import { TransactionExtended, VbytesPerSecond } from '../mempool.interfaces';
+import logger from '../logger';
+import { Common } from './common';
+import transactionUtils from './transaction-utils';
+import { IBitcoinApi } from './bitcoin/bitcoin-api.interface';
+import bitcoinBaseApi from './bitcoin/bitcoin-base.api';
+import loadingIndicators from './loading-indicators';
 
 class Mempool {
-  private mempool: IMempool = {};
-  private mempoolInfo: IMempoolInfo | undefined;
-  private mempoolChangedCallback: Function | undefined;
+  private static WEBSOCKET_REFRESH_RATE_MS = 10000;
+  private inSync: boolean = false;
+  private mempoolCache: { [txId: string]: TransactionExtended } = {};
+  private mempoolInfo: IBitcoinApi.MempoolInfo = { loaded: false, size: 0, bytes: 0, usage: 0,
+                                                    maxmempool: 0, mempoolminfee: 0, minrelaytxfee: 0 };
+  private mempoolChangedCallback: ((newMempool: {[txId: string]: TransactionExtended; }, newTransactions: TransactionExtended[],
+    deletedTransactions: TransactionExtended[]) => void) | undefined;
 
   private txPerSecondArray: number[] = [];
   private txPerSecond: number = 0;
 
-  private vBytesPerSecondArray: any[] = [];
+  private vBytesPerSecondArray: VbytesPerSecond[] = [];
   private vBytesPerSecond: number = 0;
+  private mempoolProtection = 0;
+  private latestTransactions: any[] = [];
 
   constructor() {
     setInterval(this.updateTxPerSecond.bind(this), 1000);
   }
 
-  public setMempoolChangedCallback(fn: Function) {
+  public isInSync(): boolean {
+    return this.inSync;
+  }
+
+  public setOutOfSync(): void {
+    this.inSync = false;
+    loadingIndicators.setProgress('mempool', 99);
+  }
+
+  public getLatestTransactions() {
+    return this.latestTransactions;
+  }
+
+  public setMempoolChangedCallback(fn: (newMempool: { [txId: string]: TransactionExtended; },
+    newTransactions: TransactionExtended[], deletedTransactions: TransactionExtended[]) => void) {
     this.mempoolChangedCallback = fn;
   }
 
-  public getMempool(): { [txid: string]: ITransaction } {
-    return this.mempool;
+  public getMempool(): { [txid: string]: TransactionExtended } {
+    return this.mempoolCache;
   }
 
-  public setMempool(mempoolData: any) {
-    this.mempool = mempoolData;
+  public setMempool(mempoolData: { [txId: string]: TransactionExtended }) {
+    this.mempoolCache = mempoolData;
+    if (this.mempoolChangedCallback) {
+      this.mempoolChangedCallback(this.mempoolCache, [], []);
+    }
   }
 
-  public getMempoolInfo(): IMempoolInfo | undefined {
+  public async $updateMemPoolInfo() {
+    this.mempoolInfo = await bitcoinBaseApi.$getMempoolInfo();
+  }
+
+  public getMempoolInfo(): IBitcoinApi.MempoolInfo | undefined {
     return this.mempoolInfo;
   }
 
@@ -41,125 +74,127 @@ class Mempool {
     return this.vBytesPerSecond;
   }
 
-  public async updateMemPoolInfo() {
-    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 totalOut = 0;
-      transaction.vout.forEach((output) => totalOut += output.value);
-
-      if (config.BACKEND_API === 'electrs') {
-        transaction.feePerWeightUnit = (transaction.fee * 100000000) / transaction.weight || 0;
-        transaction.feePerVsize = (transaction.fee * 100000000) / (transaction.vsize) || 0;
-        transaction.totalOut = totalOut / 100000000;
+  public getFirstSeenForTransactions(txIds: string[]): number[] {
+    const txTimes: number[] = [];
+    txIds.forEach((txId: string) => {
+      const tx = this.mempoolCache[txId];
+      if (tx && tx.firstSeen) {
+        txTimes.push(tx.firstSeen);
       } else {
-        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');
-            }
-          }
-        }
-
-        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;
+        txTimes.push(0);
       }
-      return transaction;
-    } catch (e) {
-      console.log(txId + ' not found');
-      return false;
-    }
+    });
+    return txTimes;
   }
 
-  public async updateMempool() {
-    console.log('Updating mempool');
+  public async $updateMempool() {
+    logger.debug('Updating mempool');
     const start = new Date().getTime();
     let hasChange: boolean = false;
+    const currentMempoolSize = Object.keys(this.mempoolCache).length;
     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++;
+    const transactions = await bitcoinApi.$getRawMempool();
+    const diff = transactions.length - currentMempoolSize;
+    const newTransactions: TransactionExtended[] = [];
+
+    if (!this.inSync) {
+      loadingIndicators.setProgress('mempool', Object.keys(this.mempoolCache).length / transactions.length * 100);
+    }
+
+    for (const txid of transactions) {
+      if (!this.mempoolCache[txid]) {
+        try {
+          const transaction = await transactionUtils.$getTransactionExtended(txid);
+          this.mempoolCache[txid] = transaction;
+          txCount++;
+          if (this.inSync) {
             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.');
           }
-        }
-
-        if ((new Date().getTime()) - start > config.MEMPOOL_REFRESH_RATE_MS * 10) {
-          break;
-        }
-      }
-
-      const newMempool: IMempool = {};
-      transactions.forEach((tx) => {
-        if (this.mempool[tx]) {
-          newMempool[tx] = this.mempool[tx];
-        } else {
           hasChange = true;
+          if (diff > 0) {
+            logger.debug('Fetched transaction ' + txCount + ' / ' + diff);
+          } else {
+            logger.debug('Fetched transaction ' + txCount);
+          }
+          newTransactions.push(transaction);
+        } catch (e) {
+          logger.debug('Error finding transaction in mempool: ' + e.message || e);
         }
-      });
-
-      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);
+      if ((new Date().getTime()) - start > Mempool.WEBSOCKET_REFRESH_RATE_MS) {
+        break;
+      }
     }
+
+    // Prevent mempool from clear on bitcoind restart by delaying the deletion
+    if (this.mempoolProtection === 0
+      && currentMempoolSize > 20000
+      && transactions.length / currentMempoolSize <= 0.80
+    ) {
+      this.mempoolProtection = 1;
+      this.inSync = false;
+      logger.warn(`Mempool clear protection triggered because transactions.length: ${transactions.length} and currentMempoolSize: ${currentMempoolSize}.`);
+      setTimeout(() => {
+        this.mempoolProtection = 2;
+        logger.warn('Mempool clear protection resumed.');
+      }, 1000 * 60 * config.MEMPOOL.CLEAR_PROTECTION_MINUTES);
+    }
+
+    let newMempool = {};
+    const deletedTransactions: TransactionExtended[] = [];
+
+    if (this.mempoolProtection !== 1) {
+      this.mempoolProtection = 0;
+      // Index object for faster search
+      const transactionsObject = {};
+      transactions.forEach((txId) => transactionsObject[txId] = true);
+
+      // Replace mempool to separate deleted transactions
+      for (const tx in this.mempoolCache) {
+        if (transactionsObject[tx]) {
+          newMempool[tx] = this.mempoolCache[tx];
+        } else {
+          deletedTransactions.push(this.mempoolCache[tx]);
+        }
+      }
+    } else {
+      newMempool = this.mempoolCache;
+    }
+
+    const newTransactionsStripped = newTransactions.map((tx) => Common.stripTransaction(tx));
+    this.latestTransactions = newTransactionsStripped.concat(this.latestTransactions).slice(0, 6);
+
+    if (!this.inSync && transactions.length === Object.keys(newMempool).length) {
+      this.inSync = true;
+      logger.info('The mempool is now in sync!');
+      loadingIndicators.setProgress('mempool', 100);
+    }
+
+    if (this.mempoolChangedCallback && (hasChange || deletedTransactions.length)) {
+      this.mempoolCache = newMempool;
+      this.mempoolChangedCallback(this.mempoolCache, newTransactions, deletedTransactions);
+    }
+
+    const end = new Date().getTime();
+    const time = end - start;
+    logger.debug(`New mempool size: ${Object.keys(newMempool).length} Change: ${diff}`);
+    logger.debug('Mempool updated in ' + time / 1000 + ' seconds');
   }
 
   private updateTxPerSecond() {
-    const nowMinusTimeSpan = new Date().getTime() - (1000 * config.TX_PER_SECOND_SPAN_SECONDS);
+    const nowMinusTimeSpan = new Date().getTime() - (1000 * config.STATISTICS.TX_PER_SECOND_SAMPLE_PERIOD);
     this.txPerSecondArray = this.txPerSecondArray.filter((unixTime) => unixTime > nowMinusTimeSpan);
-    this.txPerSecond = this.txPerSecondArray.length / config.TX_PER_SECOND_SPAN_SECONDS || 0;
+    this.txPerSecond = this.txPerSecondArray.length / config.STATISTICS.TX_PER_SECOND_SAMPLE_PERIOD || 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
+        this.vBytesPerSecondArray.map((data) => data.vSize).reduce((a, b) => a + b) / config.STATISTICS.TX_PER_SECOND_SAMPLE_PERIOD
       );
     }
   }

backend/src/api/projected-blocks.ts

@@ -1,101 +0,0 @@
-const config = require('../../mempool-config.json');
-import { ITransaction, IProjectedBlock, IMempool, IProjectedBlockInternal } from '../interfaces';
-
-class ProjectedBlocks {
-  private transactionsSorted: ITransaction[] = [];
-
-  constructor() {}
-
-  public getProjectedBlockFeesForBlock(index: number) {
-    const projectedBlock = this.getProjectedBlocksInternal()[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]);
-      }
-    }
-    memPoolArray.sort((a, b) => b.feePerWeightUnit - a.feePerWeightUnit);
-    this.transactionsSorted = memPoolArray.filter((tx) => tx.feePerWeightUnit);
-  }
-
-  public getProjectedBlocks(txId?: string, numberOfBlocks: number = config.DEFAULT_PROJECTED_BLOCKS_AMOUNT): IProjectedBlock[] {
-    return this.getProjectedBlocksInternal(numberOfBlocks).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
-      };
-    });
-  }
-
-  private getProjectedBlocksInternal(numberOfBlocks: number = config.DEFAULT_PROJECTED_BLOCKS_AMOUNT): IProjectedBlockInternal[] {
-    const projectedBlocks: IProjectedBlockInternal[] = [];
-    let blockWeight = 0;
-    let blockSize = 0;
-    let transactions: ITransaction[] = [];
-    this.transactionsSorted.forEach((tx) => {
-      if (blockWeight + tx.vsize * 4 < 4000000 || projectedBlocks.length === numberOfBlocks) {
-        blockWeight += tx.weight || 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));
-    }
-    return projectedBlocks;
-  }
-
-  private dataToProjectedBlock(transactions: ITransaction[], blockSize: number, blockWeight: number): IProjectedBlockInternal {
-    return {
-      blockSize: blockSize,
-      blockWeight: blockWeight,
-      nTx: transactions.length,
-      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;
-    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

@@ -1,20 +1,26 @@
 import memPool from './mempool';
 import { DB } from '../database';
+import logger from '../logger';
 
-import { ITransaction, IMempoolStats } from '../interfaces';
+import { Statistic, TransactionExtended, OptimizedStatistic } from '../mempool.interfaces';
 
 class Statistics {
   protected intervalTimer: NodeJS.Timer | undefined;
-  protected newStatisticsEntryCallback: Function | undefined;
+  protected newStatisticsEntryCallback: ((stats: OptimizedStatistic) => void) | undefined;
+  protected queryTimeout = 120000;
+  protected cache: { [date: string]: OptimizedStatistic[] } = {
+    '24h': [], '1w': [], '1m': [], '3m': [], '6m': [], '1y': [],
+  };
 
-  public setNewStatisticsEntryCallback(fn: Function) {
+  public setNewStatisticsEntryCallback(fn: (stats: OptimizedStatistic) => void) {
     this.newStatisticsEntryCallback = fn;
   }
 
-  constructor() {
-  }
+  constructor() { }
 
   public startStatistics(): void {
+    logger.info('Starting statistics service');
+
     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);
@@ -22,57 +28,61 @@ class Statistics {
 
     setTimeout(() => {
       this.runStatistics();
-      this.intervalTimer = setInterval(() => { this.runStatistics(); }, 1 * 60 * 1000);
+      this.intervalTimer = setInterval(() => {
+        this.runStatistics();
+      }, 1 * 60 * 1000);
     }, difference);
+
+    this.createCache();
+    setInterval(this.createCache.bind(this), 600000);
+  }
+
+  public getCache() {
+    return this.cache;
+  }
+
+  private async createCache() {
+    this.cache['24h'] = await this.$list24H();
+    this.cache['1w'] = await this.$list1W();
+    this.cache['1m'] = await this.$list1M();
+    this.cache['3m'] = await this.$list3M();
+    this.cache['6m'] = await this.$list6M();
+    this.cache['1y'] = await this.$list1Y();
+    logger.debug('Statistics cache created');
   }
 
   private async runStatistics(): Promise<void> {
+    if (!memPool.isInSync()) {
+      return;
+    }
     const currentMempool = memPool.getMempool();
     const txPerSecond = memPool.getTxPerSecond();
     const vBytesPerSecond = memPool.getVBytesPerSecond();
 
-    if (txPerSecond === 0) {
-      return;
-    }
+    logger.debug('Running statistics');
 
-    console.log('Running statistics');
-
-    let memPoolArray: ITransaction[] = [];
+    let memPoolArray: TransactionExtended[] = [];
     for (const i in currentMempool) {
       if (currentMempool.hasOwnProperty(i)) {
         memPoolArray.push(currentMempool[i]);
       }
     }
     // Remove 0 and undefined
-    memPoolArray = memPoolArray.filter((tx) => tx.feePerWeightUnit);
+    memPoolArray = memPoolArray.filter((tx) => tx.feePerVsize);
 
     if (!memPoolArray.length) {
       return;
     }
 
-    memPoolArray.sort((a, b) => a.feePerWeightUnit - b.feePerWeightUnit);
+    memPoolArray.sort((a, b) => a.feePerVsize - b.feePerVsize);
     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]) {
@@ -93,10 +103,7 @@ class Statistics {
       vbytes_per_second: Math.round(vBytesPerSecond),
       mempool_byte_weight: totalWeight,
       total_fee: totalFee,
-      fee_data: JSON.stringify({
-        'wu': weightUnitFees,
-        'vsize': weightVsizeFees
-      }),
+      fee_data: '',
       vsize_1: weightVsizeFees['1'] || 0,
       vsize_2: weightVsizeFees['2'] || 0,
       vsize_3: weightVsizeFees['3'] || 0,
@@ -139,11 +146,13 @@ class Statistics {
 
     if (this.newStatisticsEntryCallback && insertId) {
       const newStats = await this.$get(insertId);
-      this.newStatisticsEntryCallback(newStats);
+      if (newStats) {
+        this.newStatisticsEntryCallback(newStats);
+      }
     }
   }
 
-  private async $create(statistics: IMempoolStats): Promise<number | undefined> {
+  private async $create(statistics: Statistic): Promise<number | undefined> {
     try {
       const connection = await DB.pool.getConnection();
       const query = `INSERT INTO statistics(
@@ -246,144 +255,212 @@ class Statistics {
       connection.release();
       return result.insertId;
     } catch (e) {
-      console.log('$create() error', e);
+      logger.err('$create() error' + e.message || e);
     }
   }
 
-  private getQueryForDays(days: number, groupBy: number) {
-
+  private getQueryForDays(div: 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}`;
+      tx_per_second,
+      vbytes_per_second,
+      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 FROM statistics GROUP BY UNIX_TIMESTAMP(added) DIV ${div} ORDER BY id DESC LIMIT 480`;
   }
 
-  public async $get(id: number): Promise<IMempoolStats | undefined> {
+  public async $get(id: number): Promise<OptimizedStatistic | undefined> {
     try {
       const connection = await DB.pool.getConnection();
       const query = `SELECT * FROM statistics WHERE id = ?`;
       const [rows] = await connection.query<any>(query, [id]);
       connection.release();
-      return rows[0];
+      if (rows[0]) {
+        return this.mapStatisticToOptimizedStatistic([rows[0]])[0];
+      }
     } catch (e) {
-      console.log('$list2H() error', e);
+      logger.err('$list2H() error' + e.message || e);
     }
   }
 
-  public async $list2H(): Promise<IMempoolStats[]> {
+  public async $list2H(): Promise<OptimizedStatistic[]> {
     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);
+      const [rows] = await connection.query<any>({ sql: query, timeout: this.queryTimeout });
       connection.release();
-      return rows;
+      return this.mapStatisticToOptimizedStatistic(rows);
     } catch (e) {
-      console.log('$list2H() error', e);
+      logger.err('$list2H() error' + e.message || e);
       return [];
     }
   }
 
-  public async $list24H(): Promise<IMempoolStats[]> {
+  public async $list24H(): Promise<OptimizedStatistic[]> {
     try {
       const connection = await DB.pool.getConnection();
-      const query = this.getQueryForDays(120, 720);
-      const [rows] = await connection.query<any>(query);
+      const query = this.getQueryForDays(180);
+      const [rows] = await connection.query<any>({ sql: query, timeout: this.queryTimeout });
       connection.release();
-      return rows;
+      return this.mapStatisticToOptimizedStatistic(rows);
     } catch (e) {
+      logger.err('$list24h() error' + e.message || e);
       return [];
     }
   }
 
-  public async $list1W(): Promise<IMempoolStats[]> {
+  public async $list1W(): Promise<OptimizedStatistic[]> {
     try {
       const connection = await DB.pool.getConnection();
-      const query = this.getQueryForDays(120, 5040);
-      const [rows] = await connection.query<any>(query);
+      const query = this.getQueryForDays(1260);
+      const [rows] = await connection.query<any>({ sql: query, timeout: this.queryTimeout });
       connection.release();
-      return rows;
+      return this.mapStatisticToOptimizedStatistic(rows);
     } catch (e) {
-      console.log('$list1W() error', e);
+      logger.err('$list1W() error' + e);
       return [];
     }
   }
 
-  public async $list1M(): Promise<IMempoolStats[]> {
+  public async $list1M(): Promise<OptimizedStatistic[]> {
     try {
       const connection = await DB.pool.getConnection();
-      const query = this.getQueryForDays(120, 20160);
-      const [rows] = await connection.query<any>(query);
+      const query = this.getQueryForDays(5040);
+      const [rows] = await connection.query<any>({ sql: query, timeout: this.queryTimeout });
       connection.release();
-      return rows;
+      return this.mapStatisticToOptimizedStatistic(rows);
     } catch (e) {
-      console.log('$list1M() error', e);
+      logger.err('$list1M() error' + e);
       return [];
     }
   }
 
-  public async $list3M(): Promise<IMempoolStats[]> {
+  public async $list3M(): Promise<OptimizedStatistic[]> {
     try {
       const connection = await DB.pool.getConnection();
-      const query = this.getQueryForDays(120, 60480);
-      const [rows] = await connection.query<any>(query);
+      const query = this.getQueryForDays(15120);
+      const [rows] = await connection.query<any>({ sql: query, timeout: this.queryTimeout });
       connection.release();
-      return rows;
+      return this.mapStatisticToOptimizedStatistic(rows);
     } catch (e) {
-      console.log('$list3M() error', e);
+      logger.err('$list3M() error' + e);
       return [];
     }
   }
 
-  public async $list6M(): Promise<IMempoolStats[]> {
+  public async $list6M(): Promise<OptimizedStatistic[]> {
     try {
       const connection = await DB.pool.getConnection();
-      const query = this.getQueryForDays(120, 120960);
-      const [rows] = await connection.query<any>(query);
+      const query = this.getQueryForDays(30240);
+      const [rows] = await connection.query<any>({ sql: query, timeout: this.queryTimeout });
       connection.release();
-      return rows;
+      return this.mapStatisticToOptimizedStatistic(rows);
     } catch (e) {
-      console.log('$list6M() error', e);
+      logger.err('$list6M() error' + e);
       return [];
     }
   }
 
+  public async $list1Y(): Promise<OptimizedStatistic[]> {
+    try {
+      const connection = await DB.pool.getConnection();
+      const query = this.getQueryForDays(60480);
+      const [rows] = await connection.query<any>({ sql: query, timeout: this.queryTimeout });
+      connection.release();
+      return this.mapStatisticToOptimizedStatistic(rows);
+    } catch (e) {
+      logger.err('$list6M() error' + e);
+      return [];
+    }
+  }
+  private mapStatisticToOptimizedStatistic(statistic: Statistic[]): OptimizedStatistic[] {
+    return statistic.map((s) => {
+      return {
+        id: s.id || 0,
+        added: s.added,
+        unconfirmed_transactions: s.unconfirmed_transactions,
+        tx_per_second: s.tx_per_second,
+        vbytes_per_second: s.vbytes_per_second,
+        mempool_byte_weight: s.mempool_byte_weight,
+        total_fee: s.total_fee,
+        vsizes: [
+          s.vsize_1,
+          s.vsize_2,
+          s.vsize_3,
+          s.vsize_4,
+          s.vsize_5,
+          s.vsize_6,
+          s.vsize_8,
+          s.vsize_10,
+          s.vsize_12,
+          s.vsize_15,
+          s.vsize_20,
+          s.vsize_30,
+          s.vsize_40,
+          s.vsize_50,
+          s.vsize_60,
+          s.vsize_70,
+          s.vsize_80,
+          s.vsize_90,
+          s.vsize_100,
+          s.vsize_125,
+          s.vsize_150,
+          s.vsize_175,
+          s.vsize_200,
+          s.vsize_250,
+          s.vsize_300,
+          s.vsize_350,
+          s.vsize_400,
+          s.vsize_500,
+          s.vsize_600,
+          s.vsize_700,
+          s.vsize_800,
+          s.vsize_900,
+          s.vsize_1000,
+          s.vsize_1200,
+          s.vsize_1400,
+          s.vsize_1600,
+          s.vsize_1800,
+          s.vsize_2000,
+        ]
+      };
+    });
+  }
+
 }
 
 export default new Statistics();

backend/src/api/transaction-utils.ts

@@ -0,0 +1,40 @@
+import bitcoinApi from './bitcoin/bitcoin-api-factory';
+import logger from '../logger';
+import { TransactionExtended, TransactionMinerInfo } from '../mempool.interfaces';
+import { IEsploraApi } from './bitcoin/esplora-api.interface';
+
+class TransactionUtils {
+  constructor() { }
+
+  public stripCoinbaseTransaction(tx: TransactionExtended): TransactionMinerInfo {
+    return {
+      vin: [{
+        scriptsig: tx.vin[0].scriptsig || tx.vin[0]['coinbase']
+      }],
+      vout: tx.vout
+        .map((vout) => ({
+          scriptpubkey_address: vout.scriptpubkey_address,
+          value: vout.value
+        }))
+        .filter((vout) => vout.value)
+    };
+  }
+
+  public async $getTransactionExtended(txId: string, addPrevouts = false): Promise<TransactionExtended> {
+    const transaction: IEsploraApi.Transaction = await bitcoinApi.$getRawTransaction(txId, false, addPrevouts);
+    return this.extendTransaction(transaction);
+  }
+
+  private extendTransaction(transaction: IEsploraApi.Transaction): TransactionExtended {
+    const transactionExtended: TransactionExtended = Object.assign({
+      vsize: Math.round(transaction.weight / 4),
+      feePerVsize: Math.max(1, (transaction.fee || 0) / (transaction.weight / 4)),
+    }, transaction);
+    if (!transaction.status.confirmed) {
+      transactionExtended.firstSeen = Math.round((new Date().getTime() / 1000));
+    }
+    return transactionExtended;
+  }
+}
+
+export default new TransactionUtils();

backend/src/api/websocket-handler.ts

@@ -0,0 +1,451 @@
+import logger from '../logger';
+import * as WebSocket from 'ws';
+import { BlockExtended, TransactionExtended, WebsocketResponse, MempoolBlock,
+  OptimizedStatistic, ILoadingIndicators, IConversionRates } from '../mempool.interfaces';
+import blocks from './blocks';
+import memPool from './mempool';
+import backendInfo from './backend-info';
+import mempoolBlocks from './mempool-blocks';
+import fiatConversion from './fiat-conversion';
+import { Common } from './common';
+import loadingIndicators from './loading-indicators';
+import config from '../config';
+import transactionUtils from './transaction-utils';
+
+class WebsocketHandler {
+  private wss: WebSocket.Server | undefined;
+  private nativeAssetId = '6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d';
+  private extraInitProperties = {};
+
+  constructor() { }
+
+  setWebsocketServer(wss: WebSocket.Server) {
+    this.wss = wss;
+  }
+
+  setExtraInitProperties(property: string, value: any) {
+    this.extraInitProperties[property] = value;
+  }
+
+  setupConnectionHandling() {
+    if (!this.wss) {
+      throw new Error('WebSocket.Server is not set');
+    }
+
+    this.wss.on('connection', (client: WebSocket) => {
+      client.on('error', logger.info);
+      client.on('message', (message: string) => {
+        try {
+          const parsedMessage: WebsocketResponse = JSON.parse(message);
+          const response = {};
+
+          if (parsedMessage.action === 'want') {
+            client['want-blocks'] = parsedMessage.data.indexOf('blocks') > -1;
+            client['want-mempool-blocks'] = parsedMessage.data.indexOf('mempool-blocks') > -1;
+            client['want-live-2h-chart'] = parsedMessage.data.indexOf('live-2h-chart') > -1;
+            client['want-stats'] = parsedMessage.data.indexOf('stats') > -1;
+          }
+
+          if (parsedMessage && parsedMessage['track-tx']) {
+            if (/^[a-fA-F0-9]{64}$/.test(parsedMessage['track-tx'])) {
+              client['track-tx'] = parsedMessage['track-tx'];
+              // Client is telling the transaction wasn't found but it might have appeared before we had the time to start watching for it
+              if (parsedMessage['watch-mempool']) {
+                const tx = memPool.getMempool()[client['track-tx']];
+                if (tx) {
+                  response['tx'] = tx;
+                } else {
+                  client['track-mempool-tx'] = parsedMessage['track-tx'];
+                }
+              }
+            } else {
+              client['track-tx'] = null;
+            }
+          }
+
+          if (parsedMessage && parsedMessage['track-address']) {
+            if (/^([a-km-zA-HJ-NP-Z1-9]{26,35}|[a-km-zA-HJ-NP-Z1-9]{80}|[a-z]{2,5}1[ac-hj-np-z02-9]{8,87})$/
+              .test(parsedMessage['track-address'])) {
+              client['track-address'] = parsedMessage['track-address'];
+            } else {
+              client['track-address'] = null;
+            }
+          }
+
+          if (parsedMessage && parsedMessage['track-asset']) {
+            if (/^[a-fA-F0-9]{64}$/.test(parsedMessage['track-asset'])) {
+              client['track-asset'] = parsedMessage['track-asset'];
+            } else {
+              client['track-asset'] = null;
+            }
+          }
+
+          if (parsedMessage.action === 'init') {
+            const _blocks = blocks.getBlocks().slice(-8);
+            if (!_blocks) {
+              return;
+            }
+            client.send(JSON.stringify(this.getInitData(_blocks)));
+          }
+
+          if (parsedMessage.action === 'ping') {
+            response['pong'] = true;
+          }
+
+          if (parsedMessage['track-donation'] && parsedMessage['track-donation'].length === 22) {
+            client['track-donation'] = parsedMessage['track-donation'];
+          }
+
+          if (Object.keys(response).length) {
+            client.send(JSON.stringify(response));
+          }
+        } catch (e) {
+          logger.debug('Error parsing websocket message: ' + e.message || e);
+        }
+      });
+    });
+  }
+
+  handleNewDonation(id: string) {
+    if (!this.wss) {
+      throw new Error('WebSocket.Server is not set');
+    }
+
+    this.wss.clients.forEach((client: WebSocket) => {
+      if (client.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      if (client['track-donation'] === id) {
+        client.send(JSON.stringify({ donationConfirmed: true }));
+      }
+    });
+  }
+
+  handleLoadingChanged(indicators: ILoadingIndicators) {
+    if (!this.wss) {
+      throw new Error('WebSocket.Server is not set');
+    }
+
+    this.wss.clients.forEach((client: WebSocket) => {
+      if (client.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      client.send(JSON.stringify({ loadingIndicators: indicators }));
+    });
+  }
+
+  handleNewConversionRates(conversionRates: IConversionRates) {
+    if (!this.wss) {
+      throw new Error('WebSocket.Server is not set');
+    }
+
+    this.wss.clients.forEach((client: WebSocket) => {
+      if (client.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      client.send(JSON.stringify({ conversions: conversionRates }));
+    });
+  }
+
+  getInitData(_blocks?: BlockExtended[]) {
+    if (!_blocks) {
+      _blocks = blocks.getBlocks().slice(-8);
+    }
+    return {
+      'mempoolInfo': memPool.getMempoolInfo(),
+      'vBytesPerSecond': memPool.getVBytesPerSecond(),
+      'lastDifficultyAdjustment': blocks.getLastDifficultyAdjustmentTime(),
+      'blocks': _blocks,
+      'conversions': fiatConversion.getConversionRates(),
+      'mempool-blocks': mempoolBlocks.getMempoolBlocks(),
+      'transactions': memPool.getLatestTransactions(),
+      'git-commit': backendInfo.gitCommitHash,
+      'hostname': backendInfo.hostname,
+      'loadingIndicators': loadingIndicators.getLoadingIndicators(),
+      ...this.extraInitProperties
+    };
+  }
+
+  handleNewStatistic(stats: OptimizedStatistic) {
+    if (!this.wss) {
+      throw new Error('WebSocket.Server is not set');
+    }
+
+    this.wss.clients.forEach((client: WebSocket) => {
+      if (client.readyState !== WebSocket.OPEN) {
+        return;
+      }
+
+      if (!client['want-live-2h-chart']) {
+        return;
+      }
+
+      client.send(JSON.stringify({
+        'live-2h-chart': stats
+      }));
+    });
+  }
+
+  handleMempoolChange(newMempool: { [txid: string]: TransactionExtended },
+    newTransactions: TransactionExtended[], deletedTransactions: TransactionExtended[]) {
+    if (!this.wss) {
+      throw new Error('WebSocket.Server is not set');
+    }
+
+    mempoolBlocks.updateMempoolBlocks(newMempool);
+    const mBlocks = mempoolBlocks.getMempoolBlocks();
+    const mempoolInfo = memPool.getMempoolInfo();
+    const vBytesPerSecond = memPool.getVBytesPerSecond();
+    const rbfTransactions = Common.findRbfTransactions(newTransactions, deletedTransactions);
+
+    this.wss.clients.forEach(async (client: WebSocket) => {
+      if (client.readyState !== WebSocket.OPEN) {
+        return;
+      }
+
+      const response = {};
+
+      if (client['want-stats']) {
+        response['mempoolInfo'] = mempoolInfo;
+        response['vBytesPerSecond'] = vBytesPerSecond;
+        response['transactions'] = newTransactions.slice(0, 6).map((tx) => Common.stripTransaction(tx));
+      }
+
+      if (client['want-mempool-blocks']) {
+        response['mempool-blocks'] = mBlocks;
+      }
+
+      if (client['track-mempool-tx']) {
+        const tx = newTransactions.find((t) => t.txid === client['track-mempool-tx']);
+        if (tx) {
+          if (config.MEMPOOL.BACKEND !== 'esplora') {
+            try {
+              const fullTx = await transactionUtils.$getTransactionExtended(tx.txid, true);
+              response['tx'] = fullTx;
+            } catch (e) {
+              logger.debug('Error finding transaction in mempool: ' + e.message || e);
+            }
+          } else {
+            response['tx'] = tx;
+          }
+          client['track-mempool-tx'] = null;
+        }
+      }
+
+      if (client['track-address']) {
+        const foundTransactions: TransactionExtended[] = [];
+
+        for (const tx of newTransactions) {
+          const someVin = tx.vin.some((vin) => !!vin.prevout && vin.prevout.scriptpubkey_address === client['track-address']);
+          if (someVin) {
+            if (config.MEMPOOL.BACKEND !== 'esplora') {
+              try {
+                const fullTx = await transactionUtils.$getTransactionExtended(tx.txid, true);
+                foundTransactions.push(fullTx);
+              } catch (e) {
+                logger.debug('Error finding transaction in mempool: ' + e.message || e);
+              }
+            } else {
+              foundTransactions.push(tx);
+            }
+            return;
+          }
+          const someVout = tx.vout.some((vout) => vout.scriptpubkey_address === client['track-address']);
+          if (someVout) {
+            if (config.MEMPOOL.BACKEND !== 'esplora') {
+              try {
+                const fullTx = await transactionUtils.$getTransactionExtended(tx.txid, true);
+                foundTransactions.push(fullTx);
+              } catch (e) {
+                logger.debug('Error finding transaction in mempool: ' + e.message || e);
+              }
+            } else {
+              foundTransactions.push(tx);
+            }
+          }
+        }
+
+        if (foundTransactions.length) {
+          response['address-transactions'] = foundTransactions;
+        }
+      }
+
+      if (client['track-asset']) {
+        const foundTransactions: TransactionExtended[] = [];
+
+        newTransactions.forEach((tx) => {
+
+          if (client['track-asset'] === this.nativeAssetId) {
+            if (tx.vin.some((vin) => !!vin.is_pegin)) {
+              foundTransactions.push(tx);
+              return;
+            }
+            if (tx.vout.some((vout) => !!vout.pegout)) {
+              foundTransactions.push(tx);
+            }
+          } else {
+            if (tx.vin.some((vin) => !!vin.issuance && vin.issuance.asset_id === client['track-asset'])) {
+              foundTransactions.push(tx);
+              return;
+            }
+            if (tx.vout.some((vout) => !!vout.asset && vout.asset === client['track-asset'])) {
+              foundTransactions.push(tx);
+            }
+          }
+        });
+
+        if (foundTransactions.length) {
+          response['address-transactions'] = foundTransactions;
+        }
+      }
+
+      if (client['track-tx'] && rbfTransactions[client['track-tx']]) {
+        for (const rbfTransaction in rbfTransactions) {
+          if (client['track-tx'] === rbfTransaction) {
+            const rbfTx = rbfTransactions[rbfTransaction];
+            if (config.MEMPOOL.BACKEND !== 'esplora') {
+              try {
+                const fullTx = await transactionUtils.$getTransactionExtended(rbfTransaction, true);
+                response['rbfTransaction'] = fullTx;
+              } catch (e) {
+                logger.debug('Error finding transaction in mempool: ' + e.message || e);
+              }
+            } else {
+              response['rbfTransaction'] = rbfTx;
+            }
+            break;
+          }
+        }
+      }
+
+      if (Object.keys(response).length) {
+        client.send(JSON.stringify(response));
+      }
+    });
+  }
+
+  handleNewBlock(block: BlockExtended, txIds: string[], transactions: TransactionExtended[]) {
+    if (!this.wss) {
+      throw new Error('WebSocket.Server is not set');
+    }
+
+    // Check how many transactions in the new block matches the latest projected mempool block
+    // If it's more than 0, recalculate the mempool blocks and send to client in the same update
+    let mBlocks: undefined | MempoolBlock[];
+    let matchRate = 0;
+    const _mempoolBlocks = mempoolBlocks.getMempoolBlocksWithTransactions();
+    if (_mempoolBlocks[0]) {
+      const matches: string[] = [];
+      for (const txId of txIds) {
+        if (_mempoolBlocks[0].transactionIds.indexOf(txId) > -1) {
+          matches.push(txId);
+        }
+      }
+
+      matchRate = Math.round((matches.length / (txIds.length - 1)) * 100);
+      if (matchRate > 0) {
+        const currentMemPool = memPool.getMempool();
+        for (const txId of matches) {
+          delete currentMemPool[txId];
+        }
+        mempoolBlocks.updateMempoolBlocks(currentMemPool);
+        mBlocks = mempoolBlocks.getMempoolBlocks();
+      }
+    }
+
+    block.matchRate = matchRate;
+
+    this.wss.clients.forEach((client) => {
+      if (client.readyState !== WebSocket.OPEN) {
+        return;
+      }
+
+      if (!client['want-blocks']) {
+        return;
+      }
+
+      const response = {
+        'block': block,
+        'mempoolInfo': memPool.getMempoolInfo(),
+        'lastDifficultyAdjustment': blocks.getLastDifficultyAdjustmentTime(),
+      };
+
+      if (mBlocks && client['want-mempool-blocks']) {
+        response['mempool-blocks'] = mBlocks;
+      }
+
+      if (client['track-tx'] && txIds.indexOf(client['track-tx']) > -1) {
+        client['track-tx'] = null;
+        response['txConfirmed'] = true;
+      }
+
+      if (client['track-address']) {
+        const foundTransactions: TransactionExtended[] = [];
+
+        transactions.forEach((tx) => {
+          if (tx.vin && tx.vin.some((vin) => !!vin.prevout && vin.prevout.scriptpubkey_address === client['track-address'])) {
+            foundTransactions.push(tx);
+            return;
+          }
+          if (tx.vout && tx.vout.some((vout) => vout.scriptpubkey_address === client['track-address'])) {
+            foundTransactions.push(tx);
+          }
+        });
+
+        if (foundTransactions.length) {
+          foundTransactions.forEach((tx) => {
+            tx.status = {
+              confirmed: true,
+              block_height: block.height,
+              block_hash: block.id,
+              block_time: block.timestamp,
+            };
+          });
+
+          response['block-transactions'] = foundTransactions;
+        }
+      }
+
+      if (client['track-asset']) {
+        const foundTransactions: TransactionExtended[] = [];
+
+        transactions.forEach((tx) => {
+          if (client['track-asset'] === this.nativeAssetId) {
+            if (tx.vin && tx.vin.some((vin) => !!vin.is_pegin)) {
+              foundTransactions.push(tx);
+              return;
+            }
+            if (tx.vout && tx.vout.some((vout) => !!vout.pegout)) {
+              foundTransactions.push(tx);
+            }
+          } else {
+            if (tx.vin && tx.vin.some((vin) => !!vin.issuance && vin.issuance.asset_id === client['track-asset'])) {
+              foundTransactions.push(tx);
+              return;
+            }
+            if (tx.vout && tx.vout.some((vout) => !!vout.asset && vout.asset === client['track-asset'])) {
+              foundTransactions.push(tx);
+            }
+          }
+        });
+
+        if (foundTransactions.length) {
+          foundTransactions.forEach((tx) => {
+            tx.status = {
+              confirmed: true,
+              block_height: block.height,
+              block_hash: block.id,
+              block_time: block.timestamp,
+            };
+          });
+
+          response['block-transactions'] = foundTransactions;
+        }
+      }
+
+      client.send(JSON.stringify(response));
+    });
+  }
+}
+
+export default new WebsocketHandler();

backend/src/config.ts

@@ -0,0 +1,146 @@
+const configFile = require('../mempool-config.json');
+
+interface IConfig {
+  MEMPOOL: {
+    NETWORK: 'mainnet' | 'testnet' | 'liquid';
+    BACKEND: 'esplora' | 'electrum' | 'none';
+    HTTP_PORT: number;
+    SPAWN_CLUSTER_PROCS: number;
+    API_URL_PREFIX: string;
+    POLL_RATE_MS: number;
+    CACHE_DIR: string;
+    CLEAR_PROTECTION_MINUTES: number;
+  };
+  ESPLORA: {
+    REST_API_URL: string;
+  };
+  ELECTRUM: {
+    HOST: string;
+    PORT: number;
+    TLS_ENABLED: boolean;
+  };
+  CORE_RPC: {
+    HOST: string;
+    PORT: number;
+    USERNAME: string;
+    PASSWORD: string;
+  };
+  CORE_RPC_MINFEE: {
+    ENABLED: boolean;
+    HOST: string;
+    PORT: number;
+    USERNAME: string;
+    PASSWORD: string;
+  };
+  DATABASE: {
+    ENABLED: boolean;
+    HOST: string,
+    PORT: number;
+    DATABASE: string;
+    USERNAME: string;
+    PASSWORD: string;
+  };
+  STATISTICS: {
+    ENABLED: boolean;
+    TX_PER_SECOND_SAMPLE_PERIOD: number;
+  };
+  BISQ_BLOCKS: {
+    ENABLED: boolean;
+    DATA_PATH: string;
+  };
+  BISQ_MARKETS: {
+    ENABLED: boolean;
+    DATA_PATH: string;
+  };
+}
+
+const defaults: IConfig = {
+  'MEMPOOL': {
+    'NETWORK': 'mainnet',
+    'BACKEND': 'none',
+    'HTTP_PORT': 8999,
+    'SPAWN_CLUSTER_PROCS': 0,
+    'API_URL_PREFIX': '/api/v1/',
+    'POLL_RATE_MS': 2000,
+    'CACHE_DIR': './cache',
+    'CLEAR_PROTECTION_MINUTES': 20,
+  },
+  'ESPLORA': {
+    'REST_API_URL': 'http://127.0.0.1:3000',
+  },
+  'ELECTRUM': {
+    'HOST': '127.0.0.1',
+    'PORT': 3306,
+    'TLS_ENABLED': true,
+  },
+  'CORE_RPC': {
+    'HOST': '127.0.0.1',
+    'PORT': 8332,
+    'USERNAME': 'mempool',
+    'PASSWORD': 'mempool'
+  },
+  'CORE_RPC_MINFEE': {
+    'ENABLED': false,
+    'HOST': '127.0.0.1',
+    'PORT': 8332,
+    'USERNAME': 'mempool',
+    'PASSWORD': 'mempool'
+  },
+  'DATABASE': {
+    'ENABLED': true,
+    'HOST': '127.0.0.1',
+    'PORT': 3306,
+    'DATABASE': 'mempool',
+    'USERNAME': 'mempool',
+    'PASSWORD': 'mempool'
+  },
+  'STATISTICS': {
+    'ENABLED': true,
+    'TX_PER_SECOND_SAMPLE_PERIOD': 150
+  },
+  'BISQ_BLOCKS': {
+    'ENABLED': false,
+    'DATA_PATH': '/bisq/statsnode-data/btc_mainnet/db/json'
+  },
+  'BISQ_MARKETS': {
+    'ENABLED': false,
+    'DATA_PATH': '/bisq/statsnode-data/btc_mainnet/db'
+  },
+};
+
+class Config implements IConfig {
+  MEMPOOL: IConfig['MEMPOOL'];
+  ESPLORA: IConfig['ESPLORA'];
+  ELECTRUM: IConfig['ELECTRUM'];
+  CORE_RPC: IConfig['CORE_RPC'];
+  CORE_RPC_MINFEE: IConfig['CORE_RPC_MINFEE'];
+  DATABASE: IConfig['DATABASE'];
+  STATISTICS: IConfig['STATISTICS'];
+  BISQ_BLOCKS: IConfig['BISQ_BLOCKS'];
+  BISQ_MARKETS: IConfig['BISQ_MARKETS'];
+
+  constructor() {
+    const configs = this.merge(configFile, defaults);
+    this.MEMPOOL = configs.MEMPOOL;
+    this.ESPLORA = configs.ESPLORA;
+    this.ELECTRUM = configs.ELECTRUM;
+    this.CORE_RPC = configs.CORE_RPC;
+    this.CORE_RPC_MINFEE = configs.CORE_RPC_MINFEE;
+    this.DATABASE = configs.DATABASE;
+    this.STATISTICS = configs.STATISTICS;
+    this.BISQ_BLOCKS = configs.BISQ_BLOCKS;
+    this.BISQ_MARKETS = configs.BISQ_MARKETS;
+  }
+
+  merge = (...objects: object[]): IConfig => {
+    // @ts-ignore
+    return objects.reduce((prev, next) => {
+      Object.keys(prev).forEach(key => {
+        next[key] = { ...next[key], ...prev[key] };
+      });
+      return next;
+    });
+  }
+}
+
+export default new Config();

backend/src/database.ts

@@ -1,13 +1,14 @@
-const config = require('../mempool-config.json');
+import config from './config';
 import { createPool } from 'mysql2/promise';
+import logger from './logger';
 
 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,
+    host: config.DATABASE.HOST,
+    port: config.DATABASE.PORT,
+    database: config.DATABASE.DATABASE,
+    user: config.DATABASE.USERNAME,
+    password: config.DATABASE.PASSWORD,
     connectionLimit: 10,
     supportBigNumbers: true,
   });
@@ -16,11 +17,10 @@ export class DB {
 export async function checkDbConnection() {
   try {
     const connection = await DB.pool.getConnection();
-    console.log('MySQL connection established.');
+    logger.info('Database connection established.');
     connection.release();
   } catch (e) {
-    console.log('Could not connect to MySQL.');
-    console.log(e);
+    logger.err('Could not connect to database: ' + e.message || e);
     process.exit(1);
   }
 }

backend/src/index.ts

@@ -1,284 +1,234 @@
-const config = require('../mempool-config.json');
-import * as fs from 'fs';
+import { Express, Request, Response, NextFunction } from 'express';
 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 * as cluster from 'cluster';
+import axios from 'axios';
 
-import bitcoinApi from './api/bitcoin/bitcoin-api-factory';
-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, ITransaction, IMempoolStats } from './interfaces';
-
+import { checkDbConnection } from './database';
+import config from './config';
 import routes from './routes';
+import blocks from './api/blocks';
+import memPool from './api/mempool';
+import diskCache from './api/disk-cache';
+import statistics from './api/statistics';
+import websocketHandler from './api/websocket-handler';
 import fiatConversion from './api/fiat-conversion';
+import bisq from './api/bisq/bisq';
+import bisqMarkets from './api/bisq/markets';
+import logger from './logger';
+import backendInfo from './api/backend-info';
+import loadingIndicators from './api/loading-indicators';
+import mempool from './api/mempool';
 
-class MempoolSpace {
-  private wss: WebSocket.Server;
-  private server: https.Server | http.Server;
-  private app: any;
+class Server {
+  private wss: WebSocket.Server | undefined;
+  private server: http.Server | undefined;
+  private app: Express;
+  private currentBackendRetryInterval = 5;
 
   constructor() {
     this.app = express();
+
+    if (!config.MEMPOOL.SPAWN_CLUSTER_PROCS) {
+      this.startServer();
+      return;
+    }
+
+    if (cluster.isMaster) {
+      logger.notice(`Mempool Server (Master) is running on port ${config.MEMPOOL.HTTP_PORT} (${backendInfo.getShortCommitHash()})`);
+
+      const numCPUs = config.MEMPOOL.SPAWN_CLUSTER_PROCS;
+      for (let i = 0; i < numCPUs; i++) {
+        const env = { workerId: i };
+        const worker = cluster.fork(env);
+        worker.process['env'] = env;
+      }
+
+      cluster.on('exit', (worker, code, signal) => {
+        const workerId = worker.process['env'].workerId;
+        logger.warn(`Mempool Worker PID #${worker.process.pid} workerId: ${workerId} died. Restarting in 10 seconds... ${signal || code}`);
+        setTimeout(() => {
+          const env = { workerId: workerId };
+          const newWorker = cluster.fork(env);
+          newWorker.process['env'] = env;
+        }, 10000);
+      });
+    } else {
+      this.startServer(true);
+    }
+  }
+
+  async startServer(worker = false) {
+    logger.debug(`Starting Mempool Server${worker ? ' (worker)' : ''}... (${backendInfo.getShortCommitHash()})`);
+
     this.app
-      .use((req, res, next)  => {
+      .use((req: Request, res: Response, next: NextFunction) => {
         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 });
+      .use(express.urlencoded({ extended: true }))
+      .use(express.json());
+
+    this.server = http.createServer(this.app);
+    this.wss = new WebSocket.Server({ server: this.server });
+
+    diskCache.loadMempoolCache();
+
+    if (config.DATABASE.ENABLED) {
+      await checkDbConnection();
     }
 
-    this.setUpRoutes();
-    this.setUpWebsocketHandling();
-    this.setUpMempoolCache();
-    this.runMempoolIntervalFunctions();
+    if (config.STATISTICS.ENABLED && config.DATABASE.ENABLED) {
+      statistics.startStatistics();
+    }
 
-    statistics.startStatistics();
     fiatConversion.startService();
 
-    const opts = {
-        host: '127.0.0.1',
-        port: 8999
-    };
-    this.server.listen(opts, () => {
-      console.log(`Server started on ${opts.host}:${opts.port}`);
-    });
-  }
+    this.setUpHttpApiRoutes();
+    this.setUpWebsocketHandling();
+    this.runMainUpdateLoop();
 
-  private async runMempoolIntervalFunctions() {
-    await blocks.updateBlocks();
-    await memPool.updateMemPoolInfo();
-    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));
+    if (config.BISQ_BLOCKS.ENABLED) {
+      bisq.startBisqService();
+      bisq.setPriceCallbackFunction((price) => websocketHandler.setExtraInitProperties('bsq-price', price));
+      blocks.setNewBlockCallback(bisq.handleNewBitcoinBlock.bind(bisq));
     }
 
-    process.on('SIGINT', (options) => {
-      console.log('SIGINT');
-      diskCache.saveData(JSON.stringify(memPool.getMempool()));
-      process.exit(2);
+    if (config.BISQ_MARKETS.ENABLED) {
+      bisqMarkets.startBisqService();
+    }
+
+    this.server.listen(config.MEMPOOL.HTTP_PORT, () => {
+      if (worker) {
+        logger.info(`Mempool Server worker #${process.pid} started`);
+      } else {
+        logger.notice(`Mempool Server is running on port ${config.MEMPOOL.HTTP_PORT}`);
+      }
     });
   }
 
-  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 === 'want') {
-            client['want-stats'] = parsedMessage.data.indexOf('stats') > -1;
-            client['want-blocks'] = parsedMessage.data.indexOf('blocks') > -1;
-            client['want-projected-blocks'] = parsedMessage.data.indexOf('projected-blocks') > -1;
-            client['want-live-2h-chart'] = parsedMessage.data.indexOf('live-2h-chart') > -1;
-          }
-
-          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.getBlockAndTransactions(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['trackingTx'] = false;
-              client['blockHeight'] = 0;
-              client['tx'] = null;
-              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;
-        }
-
-        const response = {};
-
-        if (client['trackingTx'] === true && client['blockHeight'] === 0) {
-          if (block.tx.some((tx: ITransaction) => tx === client['txId'])) {
-            client['blockHeight'] = block.height;
-          }
-        }
-
-        response['track-tx'] = {
-          tracking: client['trackingTx'] || false,
-          blockHeight: client['blockHeight'],
-        };
-
-        response['block'] = formattedBlocks;
-
-        client.send(JSON.stringify(response));
-      });
-    });
-
-    memPool.setMempoolChangedCallback((newMempool: IMempool) => {
-      projectedBlocks.updateProjectedBlocks(newMempool);
-
-      const 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;
-        }
-
-        const response = {};
-
-        if (client['want-stats']) {
-          response['mempoolInfo'] = mempoolInfo;
-          response['txPerSecond'] = txPerSecond;
-          response['vBytesPerSecond'] = vBytesPerSecond;
-          response['track-tx'] = {
-            tracking: client['trackingTx'] || false,
-            blockHeight: client['blockHeight'],
-          };
-        }
-
-        if (client['want-projected-blocks'] && client['trackingTx'] && client['blockHeight'] === 0) {
-          response['projectedBlocks'] = projectedBlocks.getProjectedBlocks(client['txId']);
-        } else if (client['want-projected-blocks']) {
-          response['projectedBlocks'] = pBlocks;
-        }
-
-        if (Object.keys(response).length) {
-          client.send(JSON.stringify(response));
-        }
-      });
-    });
-
-    statistics.setNewStatisticsEntryCallback((stats: IMempoolStats) => {
-      this.wss.clients.forEach((client: WebSocket) => {
-        if (client.readyState !== WebSocket.OPEN) {
-          return;
-        }
-
-        if (client['want-live-2h-chart']) {
-          client.send(JSON.stringify({
-            'live-2h-chart': stats
-          }));
-        }
-      });
-    });
+  async runMainUpdateLoop() {
+    try {
+      await memPool.$updateMemPoolInfo();
+      await blocks.$updateBlocks();
+      await memPool.$updateMempool();
+      setTimeout(this.runMainUpdateLoop.bind(this), config.MEMPOOL.POLL_RATE_MS);
+      this.currentBackendRetryInterval = 5;
+    } catch (e) {
+      const loggerMsg = `runMainLoop error: ${(e.message || e)}. Retrying in ${this.currentBackendRetryInterval} sec.`;
+      if (this.currentBackendRetryInterval > 5) {
+        logger.warn(loggerMsg);
+        mempool.setOutOfSync();
+      } else {
+        logger.debug(loggerMsg);
+      }
+      logger.debug(JSON.stringify(e));
+      setTimeout(this.runMainUpdateLoop.bind(this), 1000 * this.currentBackendRetryInterval);
+      this.currentBackendRetryInterval *= 2;
+      this.currentBackendRetryInterval = Math.min(this.currentBackendRetryInterval, 60);
+    }
   }
 
-  private setUpRoutes() {
+  setUpWebsocketHandling() {
+    if (this.wss) {
+      websocketHandler.setWebsocketServer(this.wss);
+    }
+    websocketHandler.setupConnectionHandling();
+    statistics.setNewStatisticsEntryCallback(websocketHandler.handleNewStatistic.bind(websocketHandler));
+    blocks.setNewBlockCallback(websocketHandler.handleNewBlock.bind(websocketHandler));
+    memPool.setMempoolChangedCallback(websocketHandler.handleMempoolChange.bind(websocketHandler));
+    fiatConversion.setProgressChangedCallback(websocketHandler.handleNewConversionRates.bind(websocketHandler));
+    loadingIndicators.setProgressChangedCallback(websocketHandler.handleLoadingChanged.bind(websocketHandler));
+  }
+
+  setUpHttpApiRoutes() {
     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 + 'fees/projected-blocks', routes.getProjectedBlocks)
-      .get(config.API_ENDPOINT + 'statistics/2h', routes.get2HStatistics)
-      .get(config.API_ENDPOINT + 'statistics/24h', routes.get24HStatistics.bind(routes))
-      .get(config.API_ENDPOINT + 'statistics/1w', routes.get1WHStatistics.bind(routes))
-      .get(config.API_ENDPOINT + 'statistics/1m', routes.get1MStatistics.bind(routes))
-      .get(config.API_ENDPOINT + 'statistics/3m', routes.get3MStatistics.bind(routes))
-      .get(config.API_ENDPOINT + 'statistics/6m', routes.get6MStatistics.bind(routes))
-      ;
+      .get(config.MEMPOOL.API_URL_PREFIX + 'transaction-times', routes.getTransactionTimes)
+      .get(config.MEMPOOL.API_URL_PREFIX + 'fees/recommended', routes.getRecommendedFees)
+      .get(config.MEMPOOL.API_URL_PREFIX + 'fees/mempool-blocks', routes.getMempoolBlocks)
+      .get(config.MEMPOOL.API_URL_PREFIX + 'backend-info', routes.getBackendInfo)
+      .get(config.MEMPOOL.API_URL_PREFIX + 'init-data', routes.getInitData)
+      .get(config.MEMPOOL.API_URL_PREFIX + 'donations', async (req, res) => {
+        try {
+          const response = await axios.get('https://mempool.space/api/v1/donations', { responseType: 'stream', timeout: 10000 });
+          response.data.pipe(res);
+        } catch (e) {
+          res.status(500).end();
+        }
+      })
+      .get(config.MEMPOOL.API_URL_PREFIX + 'donations/images/:id', async (req, res) => {
+        try {
+          const response = await axios.get('https://mempool.space/api/v1/donations/images/' + req.params.id, {
+            responseType: 'stream', timeout: 10000
+          });
+          response.data.pipe(res);
+        } catch (e) {
+          res.status(500).end();
+        }
+      })
+    ;
 
-    if (config.BACKEND_API === 'electrs') {
+    if (config.STATISTICS.ENABLED && config.DATABASE.ENABLED) {
       this.app
-        .get(config.API_ENDPOINT + 'explorer/blocks', routes.getBlocks)
-        .get(config.API_ENDPOINT + 'explorer/blocks/:height', routes.getBlocks)
-        .get(config.API_ENDPOINT + 'explorer/tx/:id', routes.getRawTransaction)
-        .get(config.API_ENDPOINT + 'explorer/block/:hash', routes.getBlock)
-        .get(config.API_ENDPOINT + 'explorer/block/:hash/tx', routes.getBlockTransactions)
-        .get(config.API_ENDPOINT + 'explorer/block/:hash/tx/:index', routes.getBlockTransactionsFromIndex)
-        .get(config.API_ENDPOINT + 'explorer/address/:address', routes.getAddress)
-        .get(config.API_ENDPOINT + 'explorer/address/:address/tx', routes.getAddressTransactions)
-        .get(config.API_ENDPOINT + 'explorer/address/:address/tx/chain/:txid', routes.getAddressTransactionsFromTxid)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'statistics/2h', routes.get2HStatistics)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'statistics/24h', routes.get24HStatistics.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'statistics/1w', routes.get1WHStatistics.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'statistics/1m', routes.get1MStatistics.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'statistics/3m', routes.get3MStatistics.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'statistics/6m', routes.get6MStatistics.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'statistics/1y', routes.get1YStatistics.bind(routes))
         ;
     }
 
+    if (config.BISQ_BLOCKS.ENABLED) {
+      this.app
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/stats', routes.getBisqStats)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/tx/:txId', routes.getBisqTransaction)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/block/:hash', routes.getBisqBlock)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/blocks/tip/height', routes.getBisqTip)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/blocks/:index/:length', routes.getBisqBlocks)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/address/:address', routes.getBisqAddress)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/txs/:index/:length', routes.getBisqTransactions)
+      ;
+    }
+
+    if (config.BISQ_MARKETS.ENABLED) {
+      this.app
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/markets/currencies', routes.getBisqMarketCurrencies.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/markets/depth', routes.getBisqMarketDepth.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/markets/hloc', routes.getBisqMarketHloc.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/markets/markets', routes.getBisqMarketMarkets.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/markets/offers', routes.getBisqMarketOffers.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/markets/ticker', routes.getBisqMarketTicker.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/markets/trades', routes.getBisqMarketTrades.bind(routes))
+        .get(config.MEMPOOL.API_URL_PREFIX + 'bisq/markets/volumes', routes.getBisqMarketVolumes.bind(routes))
+        ;
+    }
+
+    if (config.MEMPOOL.BACKEND !== 'esplora') {
+      this.app
+        .get(config.MEMPOOL.API_URL_PREFIX + 'mempool', routes.getMempool)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'mempool/txids', routes.getMempoolTxIds)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'mempool/recent', routes.getRecentMempoolTransactions)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'tx/:txId', routes.getTransaction)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'tx/:txId/status', routes.getTransactionStatus)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'tx/:txId/outspends', routes.getTransactionOutspends)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'block/:hash', routes.getBlock)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'blocks', routes.getBlocks)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'blocks/:height', routes.getBlocks)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'blocks/tip/height', routes.getBlockTipHeight)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'block/:hash/txs', routes.getBlockTransactions)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'block/:hash/txs/:index', routes.getBlockTransactions)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'block/:hash/txids', routes.getTxIdsForBlock)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'block-height/:height', routes.getBlockHeight)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'address/:address', routes.getAddress)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'address/:address/txs', routes.getAddressTransactions)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'address/:address/txs/chain/:txId', routes.getAddressTransactions)
+        .get(config.MEMPOOL.API_URL_PREFIX + 'address-prefix/:prefix', routes.getAddressPrefix)
+      ;
     }
   }
+}
 
-const mempoolSpace = new MempoolSpace();
+const server = new Server();

backend/src/interfaces.ts

@@ -1,152 +0,0 @@
-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;
-  weight: 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/logger.ts

@@ -0,0 +1,149 @@
+import config from './config';
+import * as dgram from 'dgram';
+
+class Logger {
+  static priorities = {
+    emerg: 0,
+    alert: 1,
+    crit: 2,
+    err: 3,
+    warn: 4,
+    notice: 5,
+    info: 6,
+    debug: 7
+  };
+  static facilities = {
+    kern: 0,
+    user: 1,
+    mail: 2,
+    daemon: 3,
+    auth: 4,
+    syslog: 5,
+    lpr: 6,
+    news: 7,
+    uucp: 8,
+    local0: 16,
+    local1: 17,
+    local2: 18,
+    local3: 19,
+    local4: 20,
+    local5: 21,
+    local6: 22,
+    local7: 23
+  };
+
+  // @ts-ignore
+  public emerg: ((msg: string) => void);
+  // @ts-ignore
+  public alert: ((msg: string) => void);
+  // @ts-ignore
+  public crit: ((msg: string) => void);
+  // @ts-ignore
+  public err: ((msg: string) => void);
+  // @ts-ignore
+  public warn: ((msg: string) => void);
+  // @ts-ignore
+  public notice: ((msg: string) => void);
+  // @ts-ignore
+  public info: ((msg: string) => void);
+  // @ts-ignore
+  public debug: ((msg: string) => void);
+
+  private name = 'mempool';
+  private fac: any;
+  private loghost: string;
+  private logport: number;
+  private client: dgram.Socket;
+  private network: string;
+
+  constructor(fac) {
+    let prio;
+    this.fac = fac != null ? fac : Logger.facilities.local0;
+    this.loghost = '127.0.0.1';
+    this.logport = 514;
+    for (prio in Logger.priorities) {
+      if (true) {
+        this.addprio(prio);
+      }
+    }
+    this.client = dgram.createSocket('udp4');
+    this.network = this.getNetwork();
+  }
+
+  private addprio(prio): void {
+    this[prio] = (function(_this) {
+      return function(msg) {
+        return _this.msg(prio, msg);
+      };
+    })(this);
+  }
+
+  private getNetwork(): string {
+    if (config.BISQ_BLOCKS.ENABLED) {
+      return 'bisq';
+    }
+    if (config.MEMPOOL.NETWORK && config.MEMPOOL.NETWORK !== 'mainnet') {
+      return config.MEMPOOL.NETWORK;
+    }
+    return '';
+  }
+
+  private msg(priority, msg) {
+    let consolemsg, prionum, syslogmsg;
+    if (typeof msg === 'string' && msg.length > 0) {
+      while (msg[msg.length - 1].charCodeAt(0) === 10) {
+        msg = msg.slice(0, msg.length - 1);
+      }
+    }
+    const network = this.network ? ' <' + this.network + '>' : '';
+    prionum = Logger.priorities[priority] || Logger.priorities.info;
+    syslogmsg = `<${(this.fac * 8 + prionum)}> ${this.name}[${process.pid}]: ${priority.toUpperCase()}${network} ${msg}`;
+    consolemsg = `${this.ts()} [${process.pid}] ${priority.toUpperCase()}:${network} ${msg}`;
+
+    this.syslog(syslogmsg);
+    if (priority === 'warning') {
+      priority = 'warn';
+    }
+    if (priority === 'debug') {
+      priority = 'info';
+    }
+    if (priority === 'err') {
+      priority = 'error';
+    }
+    return (console[priority] || console.error)(consolemsg);
+  }
+
+  private syslog(msg) {
+    let msgbuf;
+    msgbuf = Buffer.from(msg);
+    this.client.send(msgbuf, 0, msgbuf.length, this.logport, this.loghost, function(err, bytes) {
+      if (err) {
+        console.log(err);
+      }
+    });
+  }
+
+  private leadZero(n: number): number | string {
+    if (n < 10) {
+      return '0' + n;
+    }
+    return n;
+  }
+
+  private ts() {
+    let day, dt, hours, minutes, month, months, seconds;
+    dt = new Date();
+    hours = this.leadZero(dt.getHours());
+    minutes = this.leadZero(dt.getMinutes());
+    seconds = this.leadZero(dt.getSeconds());
+    month = dt.getMonth();
+    day = dt.getDate();
+    if (day < 10) {
+      day = ' ' + day;
+    }
+    months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    return months[month] + ' ' + day + ' ' + hours + ':' + minutes + ':' + seconds;
+  }
+}
+
+export default new Logger(Logger.facilities.local7);

backend/src/mempool.interfaces.ts

@@ -0,0 +1,140 @@
+import { IEsploraApi } from './api/bitcoin/esplora-api.interface';
+
+export interface MempoolBlock {
+  blockSize: number;
+  blockVSize: number;
+  nTx: number;
+  medianFee: number;
+  totalFees: number;
+  feeRange: number[];
+}
+
+export interface MempoolBlockWithTransactions extends MempoolBlock {
+  transactionIds: string[];
+}
+
+interface VinStrippedToScriptsig {
+  scriptsig: string;
+}
+
+interface VoutStrippedToScriptPubkey {
+  scriptpubkey_address: string | undefined;
+  value: number;
+}
+
+export interface TransactionExtended extends IEsploraApi.Transaction {
+  vsize: number;
+  feePerVsize: number;
+  firstSeen?: number;
+}
+
+export interface TransactionStripped {
+  txid: string;
+  fee: number;
+  vsize: number;
+  value: number;
+}
+export interface BlockExtended extends IEsploraApi.Block {
+  medianFee?: number;
+  feeRange?: number[];
+  reward?: number;
+  coinbaseTx?: TransactionMinerInfo;
+  matchRate?: number;
+}
+
+export interface TransactionMinerInfo {
+  vin: VinStrippedToScriptsig[];
+  vout: VoutStrippedToScriptPubkey[];
+}
+
+export interface MempoolStats {
+  funded_txo_count: number;
+  funded_txo_sum: number;
+  spent_txo_count: number;
+  spent_txo_sum: number;
+  tx_count: number;
+}
+
+export interface Statistic {
+  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 OptimizedStatistic {
+  id: number;
+  added: string;
+  unconfirmed_transactions: number;
+  tx_per_second: number;
+  vbytes_per_second: number;
+  total_fee: number;
+  mempool_byte_weight: number;
+  vsizes: number[];
+}
+
+export interface WebsocketResponse {
+  action: string;
+  data: string[];
+  'track-tx': string;
+  'track-address': string;
+  'watch-mempool': boolean;
+}
+
+export interface VbytesPerSecond {
+  unixTime: number;
+  vSize: number;
+}
+
+export interface RequiredSpec { [name: string]: RequiredParams; }
+
+interface RequiredParams {
+  required: boolean;
+  types: ('@string' | '@number' | '@boolean' | string)[];
+}
+
+export interface ILoadingIndicators { [name: string]: number; }
+export interface IConversionRates { [currency: string]: number; }

backend/src/routes.ts

@@ -1,197 +1,636 @@
+import config from './config';
+import { Request, Response } from 'express';
 import statistics from './api/statistics';
 import feeApi from './api/fee-api';
-import projectedBlocks from './api/projected-blocks';
+import backendInfo from './api/backend-info';
+import mempoolBlocks from './api/mempool-blocks';
+import mempool from './api/mempool';
+import bisq from './api/bisq/bisq';
+import websocketHandler from './api/websocket-handler';
+import bisqMarket from './api/bisq/markets-api';
+import { RequiredSpec, TransactionExtended } from './mempool.interfaces';
+import { MarketsApiError } from './api/bisq/interfaces';
+import { IEsploraApi } from './api/bitcoin/esplora-api.interface';
+import logger from './logger';
 import bitcoinApi from './api/bitcoin/bitcoin-api-factory';
+import transactionUtils from './api/transaction-utils';
+import blocks from './api/blocks';
+import loadingIndicators from './api/loading-indicators';
+import { Common } from './api/common';
 
 class Routes {
-  private cache = {};
+  constructor() {}
 
-  constructor() {
-    this.createCache();
-    setInterval(this.createCache.bind(this), 600000);
-  }
-
-  private async createCache() {
-    this.cache['24h'] = await statistics.$list24H();
-    this.cache['1w'] = await statistics.$list1W();
-    this.cache['1m'] = await statistics.$list1M();
-    this.cache['3m'] = await statistics.$list3M();
-    this.cache['6m'] = await statistics.$list6M();
-    console.log('Statistics cache created');
-  }
-
-  public async get2HStatistics(req, res) {
+  public async get2HStatistics(req: Request, res: Response) {
     const result = await statistics.$list2H();
-    res.send(result);
+    res.json(result);
   }
 
-  public get24HStatistics(req, res) {
-    res.send(this.cache['24h']);
+  public get24HStatistics(req: Request, res: Response) {
+    res.json(statistics.getCache()['24h']);
   }
 
-  public get1WHStatistics(req, res) {
-    res.send(this.cache['1w']);
+  public get1WHStatistics(req: Request, res: Response) {
+    res.json(statistics.getCache()['1w']);
   }
 
-  public get1MStatistics(req, res) {
-    res.send(this.cache['1m']);
+  public get1MStatistics(req: Request, res: Response) {
+    res.json(statistics.getCache()['1m']);
   }
 
-  public get3MStatistics(req, res) {
-    res.send(this.cache['3m']);
+  public get3MStatistics(req: Request, res: Response) {
+    res.json(statistics.getCache()['3m']);
   }
 
-  public get6MStatistics(req, res) {
-    res.send(this.cache['6m']);
+  public get6MStatistics(req: Request, res: Response) {
+    res.json(statistics.getCache()['6m']);
   }
 
-  public async getRecommendedFees(req, res) {
+  public get1YStatistics(req: Request, res: Response) {
+    res.json(statistics.getCache()['1y']);
+  }
+
+  public getInitData(req: Request, res: Response) {
+    try {
+      const result = websocketHandler.getInitData();
+      res.json(result);
+    } catch (e) {
+      res.status(500).send(e.message);
+    }
+  }
+
+  public async getRecommendedFees(req: Request, res: Response) {
+    if (!mempool.isInSync()) {
+      res.statusCode = 503;
+      res.send('Service Unavailable');
+      return;
+    }
     const result = feeApi.getRecommendedFee();
-    res.send(result);
+    res.json(result);
   }
 
-  public async $getgetTransactionsForBlock(req, res) {
-    const result = await feeApi.$getTransactionsForBlock(req.params.id);
-    res.send(result);
-  }
-
-  public async getgetTransactionsForProjectedBlock(req, res) {
+  public getMempoolBlocks(req: Request, res: Response) {
     try {
-      const result = await projectedBlocks.getProjectedBlockFeesForBlock(req.params.id);
-      res.send(result);
+      const result = mempoolBlocks.getMempoolBlocks();
+      res.json(result);
     } catch (e) {
       res.status(500).send(e.message);
     }
   }
 
-  public async getProjectedBlocks(req, res) {
-    try {
-      let txId: string | undefined;
-      if (req.query.txId && /^[a-fA-F0-9]{64}$/.test(req.query.txId)) {
-        txId = req.query.txId;
+  public getTransactionTimes(req: Request, res: Response) {
+    if (!Array.isArray(req.query.txId)) {
+      res.status(500).send('Not an array');
+      return;
+    }
+    const txIds: string[] = [];
+    for (const _txId in req.query.txId) {
+      if (typeof req.query.txId[_txId] === 'string') {
+        txIds.push(req.query.txId[_txId].toString());
       }
-      const result = await projectedBlocks.getProjectedBlocks(txId, 6);
-      res.send(result);
-    } catch (e) {
-      res.status(500).send(e.message);
+    }
+
+    const times = mempool.getFirstSeenForTransactions(txIds);
+    res.json(times);
+  }
+
+  public getBackendInfo(req: Request, res: Response) {
+    res.json(backendInfo.getBackendInfo());
+  }
+
+  public getBisqStats(req: Request, res: Response) {
+    const result = bisq.getStats();
+    res.json(result);
+  }
+
+  public getBisqTip(req: Request, res: Response) {
+    const result = bisq.getLatestBlockHeight();
+    res.type('text/plain');
+    res.send(result.toString());
+  }
+
+  public getBisqTransaction(req: Request, res: Response) {
+    const result = bisq.getTransaction(req.params.txId);
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(404).send('Bisq transaction not found');
     }
   }
 
-  public async getBlocks(req, res) {
-    try {
-      let result: string;
-      if (req.params.height) {
-        result = await bitcoinApi.getBlocksFromHeight(req.params.height);
-      } else {
-        result = await bitcoinApi.getBlocks();
+  public getBisqTransactions(req: Request, res: Response) {
+    const types: string[] = [];
+    req.query.types = req.query.types || [];
+    if (!Array.isArray(req.query.types)) {
+      res.status(500).send('Types is not an array');
+      return;
+    }
+
+    for (const _type in req.query.types) {
+      if (typeof req.query.types[_type] === 'string') {
+        types.push(req.query.types[_type].toString());
       }
-      res.send(result);
-    } catch (e) {
-      res.status(500).send(e.message);
+    }
+
+    const index = parseInt(req.params.index, 10) || 0;
+    const length = parseInt(req.params.length, 10) > 100 ? 100 : parseInt(req.params.length, 10) || 25;
+    const [transactions, count] = bisq.getTransactions(index, length, types);
+    res.header('X-Total-Count', count.toString());
+    res.json(transactions);
+  }
+
+  public getBisqBlock(req: Request, res: Response) {
+    const result = bisq.getBlock(req.params.hash);
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(404).send('Bisq block not found');
     }
   }
 
-  public async getRawTransaction(req, res) {
-    try {
-      const result = await bitcoinApi.getRawTransaction(req.params.id);
-      res.send(result);
-    } catch (e) {
-      if (e.response) {
-        res.status(e.response.status).send(e.response.data);
-      } else {
-        res.status(500, e.message);
-      }
+  public getBisqBlocks(req: Request, res: Response) {
+    const index = parseInt(req.params.index, 10) || 0;
+    const length = parseInt(req.params.length, 10) > 100 ? 100 : parseInt(req.params.length, 10) || 25;
+    const [transactions, count] = bisq.getBlocks(index, length);
+    res.header('X-Total-Count', count.toString());
+    res.json(transactions);
+  }
+
+  public getBisqAddress(req: Request, res: Response) {
+    const result = bisq.getAddress(req.params.address.substr(1));
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(404).send('Bisq address not found');
     }
   }
 
-  public async getBlock(req, res) {
-    try {
-      const result = await bitcoinApi.getBlock(req.params.hash);
-      res.send(result);
-    } catch (e) {
-      if (e.response) {
-        res.status(e.response.status).send(e.response.data);
-      } else {
-        res.status(500, e.message);
-      }
+  public getBisqMarketCurrencies(req: Request, res: Response) {
+    const constraints: RequiredSpec = {
+      'type': {
+        required: false,
+        types: ['crypto', 'fiat', 'all']
+      },
+    };
+
+    const p = this.parseRequestParameters(req.query, constraints);
+    if (p.error) {
+      res.status(400).json(this.getBisqMarketErrorResponse(p.error));
+      return;
+    }
+
+    const result = bisqMarket.getCurrencies(p.type);
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(500).json(this.getBisqMarketErrorResponse('getBisqMarketCurrencies error'));
     }
   }
 
-  public async getBlockTransactions(req, res) {
-    try {
-      const result = await bitcoinApi.getBlockTransactions(req.params.hash);
-      res.send(result);
-    } catch (e) {
-      if (e.response) {
-        res.status(e.response.status).send(e.response.data);
-      } else {
-        if (e.response) {
-          res.status(e.response.status).send(e.response.data);
-        } else {
-          res.status(500, e.message);
+  public getBisqMarketDepth(req: Request, res: Response) {
+    const constraints: RequiredSpec = {
+      'market': {
+        required: true,
+        types: ['@string']
+      },
+    };
+
+    const p = this.parseRequestParameters(req.query, constraints);
+    if (p.error) {
+      res.status(400).json(this.getBisqMarketErrorResponse(p.error));
+      return;
+    }
+
+    const result = bisqMarket.getDepth(p.market);
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(500).json(this.getBisqMarketErrorResponse('getBisqMarketDepth error'));
+    }
+  }
+
+  public getBisqMarketMarkets(req: Request, res: Response) {
+    const result = bisqMarket.getMarkets();
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(500).json(this.getBisqMarketErrorResponse('getBisqMarketMarkets error'));
+    }
+  }
+
+  public getBisqMarketTrades(req: Request, res: Response) {
+    const constraints: RequiredSpec = {
+      'market': {
+        required: true,
+        types: ['@string']
+      },
+      'timestamp_from': {
+        required: false,
+        types: ['@number']
+      },
+      'timestamp_to': {
+        required: false,
+        types: ['@number']
+      },
+      'trade_id_to': {
+        required: false,
+        types: ['@string']
+      },
+      'trade_id_from': {
+        required: false,
+        types: ['@string']
+      },
+      'direction': {
+        required: false,
+        types: ['buy', 'sell']
+      },
+      'limit': {
+        required: false,
+        types: ['@number']
+      },
+      'sort': {
+        required: false,
+        types: ['asc', 'desc']
+      }
+    };
+
+    const p = this.parseRequestParameters(req.query, constraints);
+    if (p.error) {
+      res.status(400).json(this.getBisqMarketErrorResponse(p.error));
+      return;
+    }
+
+    const result = bisqMarket.getTrades(p.market, p.timestamp_from,
+      p.timestamp_to, p.trade_id_from, p.trade_id_to, p.direction, p.limit, p.sort);
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(500).json(this.getBisqMarketErrorResponse('getBisqMarketTrades error'));
+    }
+  }
+
+  public getBisqMarketOffers(req: Request, res: Response) {
+    const constraints: RequiredSpec = {
+      'market': {
+        required: true,
+        types: ['@string']
+      },
+      'direction': {
+        required: false,
+        types: ['buy', 'sell']
+      },
+    };
+
+    const p = this.parseRequestParameters(req.query, constraints);
+    if (p.error) {
+      res.status(400).json(this.getBisqMarketErrorResponse(p.error));
+      return;
+    }
+
+    const result = bisqMarket.getOffers(p.market, p.direction);
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(500).json(this.getBisqMarketErrorResponse('getBisqMarketOffers error'));
+    }
+  }
+
+  public getBisqMarketVolumes(req: Request, res: Response) {
+    const constraints: RequiredSpec = {
+      'market': {
+        required: false,
+        types: ['@string']
+      },
+      'interval': {
+        required: false,
+        types: ['minute', 'half_hour', 'hour', 'half_day', 'day', 'week', 'month', 'year', 'auto']
+      },
+      'timestamp_from': {
+        required: false,
+        types: ['@number']
+      },
+      'timestamp_to': {
+        required: false,
+        types: ['@number']
+      },
+      'milliseconds': {
+        required: false,
+        types: ['@boolean']
+      },
+      'timestamp': {
+        required: false,
+        types: ['no', 'yes']
+      },
+    };
+
+    const p = this.parseRequestParameters(req.query, constraints);
+    if (p.error) {
+      res.status(400).json(this.getBisqMarketErrorResponse(p.error));
+      return;
+    }
+
+    const result = bisqMarket.getVolumes(p.market, p.timestamp_from, p.timestamp_to, p.interval, p.milliseconds, p.timestamp);
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(500).json(this.getBisqMarketErrorResponse('getBisqMarketVolumes error'));
+    }
+  }
+
+  public getBisqMarketHloc(req: Request, res: Response) {
+    const constraints: RequiredSpec = {
+      'market': {
+        required: true,
+        types: ['@string']
+      },
+      'interval': {
+        required: false,
+        types: ['minute', 'half_hour', 'hour', 'half_day', 'day', 'week', 'month', 'year', 'auto']
+      },
+      'timestamp_from': {
+        required: false,
+        types: ['@number']
+      },
+      'timestamp_to': {
+        required: false,
+        types: ['@number']
+      },
+      'milliseconds': {
+        required: false,
+        types: ['@boolean']
+      },
+      'timestamp': {
+        required: false,
+        types: ['no', 'yes']
+      },
+    };
+
+    const p = this.parseRequestParameters(req.query, constraints);
+    if (p.error) {
+      res.status(400).json(this.getBisqMarketErrorResponse(p.error));
+      return;
+    }
+
+    const result = bisqMarket.getHloc(p.market, p.interval, p.timestamp_from, p.timestamp_to, p.milliseconds, p.timestamp);
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(500).json(this.getBisqMarketErrorResponse('getBisqMarketHloc error'));
+    }
+  }
+
+  public getBisqMarketTicker(req: Request, res: Response) {
+    const constraints: RequiredSpec = {
+      'market': {
+        required: false,
+        types: ['@string']
+      },
+    };
+
+    const p = this.parseRequestParameters(req.query, constraints);
+    if (p.error) {
+      res.status(400).json(this.getBisqMarketErrorResponse(p.error));
+      return;
+    }
+
+    const result = bisqMarket.getTicker(p.market);
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(500).json(this.getBisqMarketErrorResponse('getBisqMarketTicker error'));
+    }
+  }
+
+  private parseRequestParameters(requestParams: object, params: RequiredSpec): { [name: string]: any; } {
+    const final = {};
+    for (const i in params) {
+      if (params.hasOwnProperty(i)) {
+        if (params[i].required && requestParams[i] === undefined) {
+          return { error: i + ' parameter missing'};
+        }
+        if (typeof requestParams[i] === 'string') {
+          const str = (requestParams[i] || '').toString().toLowerCase();
+          if (params[i].types.indexOf('@number') > -1) {
+            const number = parseInt((str).toString(), 10);
+            final[i] = number;
+          } else if (params[i].types.indexOf('@string') > -1) {
+            final[i] = str;
+          } else if (params[i].types.indexOf('@boolean') > -1) {
+            final[i] = str === 'true' || str === 'yes';
+          } else if (params[i].types.indexOf(str) > -1) {
+            final[i] = str;
+          } else {
+            return { error: i + ' parameter invalid'};
+          }
+        } else if (typeof requestParams[i] === 'number') {
+          final[i] = requestParams[i];
         }
       }
     }
+    return final;
   }
 
-  public async getBlockTransactionsFromIndex(req, res) {
+  private getBisqMarketErrorResponse(message: string): MarketsApiError {
+    return {
+      'success': 0,
+      'error': message
+    };
+  }
+
+  public async getTransaction(req: Request, res: Response) {
     try {
-      const result = await bitcoinApi.getBlockTransactionsFromIndex(req.params.hash, req.params.index);
-      res.send(result);
+      const transaction = await transactionUtils.$getTransactionExtended(req.params.txId, true);
+      res.json(transaction);
     } catch (e) {
-      if (e.response) {
-        res.status(e.response.status).send(e.response.data);
+      let statusCode = 500;
+      if (e.message && e.message.indexOf('No such mempool or blockchain transaction') > -1) {
+        statusCode = 404;
+      }
+      res.status(statusCode).send(e.message || e);
+    }
+  }
+
+  public async getTransactionStatus(req: Request, res: Response) {
+    try {
+      const transaction = await transactionUtils.$getTransactionExtended(req.params.txId, true);
+      res.json(transaction.status);
+    } catch (e) {
+      let statusCode = 500;
+      if (e.message && e.message.indexOf('No such mempool or blockchain transaction') > -1) {
+        statusCode = 404;
+      }
+      res.status(statusCode).send(e.message || e);
+    }
+  }
+
+  public async getBlock(req: Request, res: Response) {
+    try {
+      const result = await bitcoinApi.$getBlock(req.params.hash);
+      res.json(result);
+    } catch (e) {
+      res.status(500).send(e.message || e);
+    }
+  }
+
+  public async getBlocks(req: Request, res: Response) {
+    try {
+      loadingIndicators.setProgress('blocks', 0);
+
+      const returnBlocks: IEsploraApi.Block[] = [];
+      const fromHeight = parseInt(req.params.height, 10) || blocks.getCurrentBlockHeight();
+
+      // Check if block height exist in local cache to skip the hash lookup
+      const blockByHeight = blocks.getBlocks().find((b) => b.height === fromHeight);
+      let startFromHash: string | null = null;
+      if (blockByHeight) {
+        startFromHash = blockByHeight.id;
       } else {
-        if (e.response) {
-          res.status(e.response.status).send(e.response.data);
+        startFromHash = await bitcoinApi.$getBlockHash(fromHeight);
+      }
+
+      let nextHash = startFromHash;
+      for (let i = 0; i < 10; i++) {
+        const localBlock = blocks.getBlocks().find((b) => b.id === nextHash);
+        if (localBlock) {
+          returnBlocks.push(localBlock);
+          nextHash = localBlock.previousblockhash;
         } else {
-          res.status(500, e.message);
+          const block = await bitcoinApi.$getBlock(nextHash);
+          returnBlocks.push(block);
+          nextHash = block.previousblockhash;
+        }
+        loadingIndicators.setProgress('blocks', i / 10 * 100);
+      }
+
+      res.json(returnBlocks);
+    } catch (e) {
+      loadingIndicators.setProgress('blocks', 100);
+      res.status(500).send(e.message || e);
+    }
+  }
+
+  public async getBlockTransactions(req: Request, res: Response) {
+    try {
+      loadingIndicators.setProgress('blocktxs-' + req.params.hash, 0);
+
+      const txIds = await bitcoinApi.$getTxIdsForBlock(req.params.hash);
+      const transactions: TransactionExtended[] = [];
+      const startingIndex = Math.max(0, parseInt(req.params.index || '0', 10));
+
+      const endIndex = Math.min(startingIndex + 10, txIds.length);
+      for (let i = startingIndex; i < endIndex; i++) {
+        try {
+          const transaction = await transactionUtils.$getTransactionExtended(txIds[i], true);
+          transactions.push(transaction);
+          loadingIndicators.setProgress('blocktxs-' + req.params.hash, (i + 1) / endIndex * 100);
+        } catch (e) {
+          logger.debug('getBlockTransactions error: ' + e.message || e);
         }
       }
+      res.json(transactions);
+    } catch (e) {
+      loadingIndicators.setProgress('blocktxs-' + req.params.hash, 100);
+      res.status(500).send(e.message || e);
     }
   }
 
-  public async getAddress(req, res) {
+  public async getBlockHeight(req: Request, res: Response) {
     try {
-      const result = await bitcoinApi.getAddress(req.params.address);
-      res.send(result);
+      const blockHash = await bitcoinApi.$getBlockHash(parseInt(req.params.height, 10));
+      res.send(blockHash);
     } catch (e) {
-      if (e.response) {
-        res.status(e.response.status).send(e.response.data);
-      } else {
-        if (e.response) {
-          res.status(e.response.status).send(e.response.data);
-        } else {
-          res.status(500, e.message);
-        }
-      }
+      res.status(500).send(e.message || e);
     }
   }
 
-  public async getAddressTransactions(req, res) {
+  public async getAddress(req: Request, res: Response) {
+    if (config.MEMPOOL.BACKEND === 'none') {
+      res.status(405).send('Address lookups cannot be used with bitcoind as backend.');
+      return;
+    }
+
     try {
-      const result = await bitcoinApi.getAddressTransactions(req.params.address);
-      res.send(result);
+      const addressData = await bitcoinApi.$getAddress(req.params.address);
+      res.json(addressData);
     } catch (e) {
-      if (e.response) {
-        res.status(e.response.status).send(e.response.data);
-      } else {
-        res.status(500, e.message);
+      if (e.message && e.message.indexOf('exceeds') > 0) {
+        return res.status(413).send(e.message);
       }
+      res.status(500).send(e.message || e);
     }
   }
 
-  public async getAddressTransactionsFromTxid(req, res) {
-    try {
-      const result = await bitcoinApi.getAddressTransactionsFromLastSeenTxid(req.params.address, req.params.txid);
-      res.send(result);
-    } catch (e) {
-      if (e.response) {
-        res.status(e.response.status).send(e.response.data);
-      } else {
-        res.status(500, e.message);
-      }
+  public async getAddressTransactions(req: Request, res: Response) {
+    if (config.MEMPOOL.BACKEND === 'none') {
+      res.status(405).send('Address lookups cannot be used with bitcoind as backend.');
+      return;
     }
+
+    try {
+      const transactions = await bitcoinApi.$getAddressTransactions(req.params.address, req.params.txId);
+      res.json(transactions);
+    } catch (e) {
+      if (e.message && e.message.indexOf('exceeds') > 0) {
+        return res.status(413).send(e.message);
+      }
+      res.status(500).send(e.message || e);
+    }
+  }
+
+  public async getAdressTxChain(req: Request, res: Response) {
+    res.status(501).send('Not implemented');
+  }
+
+  public async getAddressPrefix(req: Request, res: Response) {
+    try {
+      const blockHash = await bitcoinApi.$getAddressPrefix(req.params.prefix);
+      res.send(blockHash);
+    } catch (e) {
+      res.status(500).send(e.message || e);
+    }
+  }
+
+  public async getRecentMempoolTransactions(req: Request, res: Response) {
+    const latestTransactions = Object.entries(mempool.getMempool())
+      .sort((a, b) => (b[1].firstSeen || 0) - (a[1].firstSeen || 0))
+      .slice(0, 10).map((tx) => Common.stripTransaction(tx[1]));
+
+    res.json(latestTransactions);
+  }
+
+  public async getMempool(req: Request, res: Response) {
+    res.status(501).send('Not implemented');
+  }
+
+  public async getMempoolTxIds(req: Request, res: Response) {
+    try {
+      const rawMempool = await bitcoinApi.$getRawMempool();
+      res.send(rawMempool);
+    } catch (e) {
+      res.status(500).send(e.message || e);
+    }
+  }
+
+  public async getBlockTipHeight(req: Request, res: Response) {
+    try {
+      const result = await bitcoinApi.$getBlockHeightTip();
+      res.json(result);
+    } catch (e) {
+      res.status(500).send(e.message || e);
+    }
+  }
+
+  public async getTxIdsForBlock(req: Request, res: Response) {
+    try {
+      const result = await bitcoinApi.$getTxIdsForBlock(req.params.hash);
+      res.json(result);
+    } catch (e) {
+      res.status(500).send(e.message || e);
+    }
+  }
+
+  public getTransactionOutspends(req: Request, res: Response) {
+    res.status(501).send('Not implemented');
   }
 }
 

backend/tsconfig.json

@@ -1,7 +1,8 @@
 {
   "compilerOptions": {
     "module": "commonjs",
-    "target": "es2015",
+    "target": "esnext",
+    "lib": ["es2019"],
     "strict": true,
     "noImplicitAny": false,
     "sourceMap": false,

backend/tslint.json

@@ -12,7 +12,7 @@
       "severity": "warn"
     },
     "eofline": true,
-    "forin": true,
+    "forin": false,
     "import-blacklist": [
       true,
       "rxjs",

docker/README.md

@@ -0,0 +1,99 @@
+# Docker
+
+## Initialization
+
+In an empty dir create 2 sub-dirs
+
+```bash
+mkdir -p data mysql/data mysql/db-scripts
+```
+
+In the `mysql/db-scripts` sub-dir add the `mariadb-structure.sql` file from the mempool repo
+
+Your dir should now look like that:
+
+```bash
+$ls -R
+.:
+data mysql
+
+./data:
+
+./mysql:
+data  db-scripts
+
+./mysql/data:
+
+./mysql/db-scripts:
+mariadb-structure.sql
+```
+
+In the main dir add the following `docker-compose.yml`
+
+```bash
+version: "3.7"
+
+services:
+  web:
+    image: mempool/frontend:latest
+    user: "1000:1000"
+    restart: on-failure
+    stop_grace_period: 1m
+    command: "./wait-for db:3306 --timeout=720 -- nginx -g 'daemon off;'"
+    ports:
+      - 80:8080
+    environment:
+      FRONTEND_HTTP_PORT: "8080"
+      BACKEND_MAINNET_HTTP_HOST: "api"
+  api:
+    image: mempool/backend:latest
+    user: "1000:1000"
+    restart: on-failure
+    stop_grace_period: 1m
+    command: "./wait-for-it.sh db:3306 --timeout=720 --strict -- ./start.sh"
+    volumes:
+      - ./data:/backend/cache
+    environment:
+      RPC_HOST: "127.0.0.1"
+      RPC_PORT: "8332"
+      RPC_USER: "mempool"
+      RPC_PASS: "mempool"
+      ELECTRS_HOST: "127.0.0.1"
+      ELECTRS_PORT: "50002"
+      MYSQL_HOST: "db"
+      MYSQL_PORT: "3306"
+      MYSQL_DATABASE: "mempool"
+      MYSQL_USER: "mempool"
+      MYSQL_PASS: "mempool"
+      BACKEND_MAINNET_HTTP_PORT: "8999"
+      CACHE_DIR: "/backend/cache/"
+  db:
+    image: mariadb:10.5.8
+    user: "1000:1000"
+    restart: on-failure
+    stop_grace_period: 1m
+    volumes:
+      - ./mysql/data:/var/lib/mysql
+      - ./mysql/db-scripts:/docker-entrypoint-initdb.d
+    environment:
+      MYSQL_DATABASE: "mempool"
+      MYSQL_USER: "mempool"
+      MYSQL_PASSWORD: "mempool"
+      MYSQL_ROOT_PASSWORD: "admin"
+
+```
+
+You can update all the environment variables inside the API container, especially the RPC and ELECTRS ones
+
+## Run it
+
+To run our docker-compose use the following cmd:
+
+```bash
+docker-compose up
+```
+
+If everything went okay you should see the beautiful mempool :grin:
+
+If you get stuck on "loading blocks", this means the websocket can't connect.
+Check your nginx proxy setup, firewalls, etc. and open an issue if you need help.

docker/backend/Dockerfile

@@ -0,0 +1,27 @@
+FROM node:12-buster-slim AS builder
+
+WORKDIR /build
+COPY . .
+
+RUN apt-get update
+RUN apt-get install -y build-essential python3 pkg-config
+RUN npm ci --production
+RUN npm i typescript
+RUN npm run build
+
+FROM node:12-buster-slim
+
+WORKDIR /backend
+
+COPY --from=builder /build/ .
+
+RUN chmod +x /backend/start.sh
+RUN chmod +x /backend/wait-for-it.sh
+
+RUN chown -R 1000:1000 /backend && chmod -R 755 /backend
+
+USER 1000
+
+EXPOSE 8999
+
+CMD ["/backend/start.sh"]

docker/backend/mempool-config.json

@@ -0,0 +1,38 @@
+{
+  "MEMPOOL": {
+    "NETWORK": "mainnet",
+    "BACKEND": "electrum",
+    "HTTP_PORT": __MEMPOOL_BACKEND_MAINNET_HTTP_PORT__,
+    "SPAWN_CLUSTER_PROCS": 0,
+    "API_URL_PREFIX": "/api/v1/",
+    "POLL_RATE_MS": 2000,
+    "CACHE_DIR": "__MEMPOOL_BACKEND_MAINNET_CACHE_DIR__"
+  },
+  "CORE_RPC": {
+    "HOST": "__BITCOIN_MAINNET_RPC_HOST__",
+    "PORT": __BITCOIN_MAINNET_RPC_PORT__,
+    "USERNAME": "__BITCOIN_MAINNET_RPC_USER__",
+    "PASSWORD": "__BITCOIN_MAINNET_RPC_PASS__"
+  },
+  "ELECTRUM": {
+    "HOST": "__ELECTRS_MAINNET_HTTP_HOST__",
+    "PORT": __ELECTRS_MAINNET_HTTP_PORT__,
+    "TLS_ENABLED": false,
+    "TX_LOOKUPS": true
+  },
+  "ESPLORA": {
+    "REST_API_URL": "http://127.0.0.1:3000"
+  },
+  "DATABASE": {
+    "ENABLED": true,
+    "HOST": "__MYSQL_HOST__",
+    "PORT": __MYSQL_PORT__,
+    "DATABASE": "__MYSQL_DATABASE__",
+    "USERNAME": "__MYSQL_USERNAME__",
+    "PASSWORD": "__MYSQL_PASSWORD__"
+  },
+  "STATISTICS": {
+    "ENABLED": true,
+    "TX_PER_SECOND_SAMPLE_PERIOD": 150
+  }
+}

docker/backend/start.sh

@@ -0,0 +1,37 @@
+#!/bin/sh
+
+#MEMPOOL
+__MEMPOOL_BACKEND_MAINNET_HTTP_PORT__=${BACKEND_MAINNET_HTTP_PORT:=8999}
+__MEMPOOL_BACKEND_MAINNET_CACHE_DIR__=${CACHE_DIR:=./}
+# BITCOIN
+__BITCOIN_MAINNET_RPC_HOST__=${RPC_HOST:=127.0.0.1}
+__BITCOIN_MAINNET_RPC_PORT__=${RPC_PORT:=8332}
+__BITCOIN_MAINNET_RPC_USER__=${RPC_USER:=mempool}
+__BITCOIN_MAINNET_RPC_PASS__=${RPC_PASS:=mempool}
+# ELECTRUM
+__ELECTRS_MAINNET_HTTP_HOST__=${ELECTRS_HOST:=127.0.0.1}
+__ELECTRS_MAINNET_HTTP_PORT__=${ELECTRS_PORT:=50002}
+# MYSQL
+__MYSQL_HOST__=${MYSQL_HOST:=127.0.0.1}
+__MYSQL_PORT__=${MYSQL_PORT:=3306}
+__MYSQL_DATABASE__=${MYSQL_DATABASE:=mempool}
+__MYSQL_USERNAME__=${MYSQL_USER:=mempool}
+__MYSQL_PASSWORD__=${MYSQL_PASS:=mempool}
+
+mkdir -p "${__MEMPOOL_BACKEND_MAINNET_CACHE_DIR__}"
+
+sed -i "s/__BITCOIN_MAINNET_RPC_HOST__/${__BITCOIN_MAINNET_RPC_HOST__}/g" mempool-config.json
+sed -i "s/__BITCOIN_MAINNET_RPC_PORT__/${__BITCOIN_MAINNET_RPC_PORT__}/g" mempool-config.json
+sed -i "s/__BITCOIN_MAINNET_RPC_USER__/${__BITCOIN_MAINNET_RPC_USER__}/g" mempool-config.json
+sed -i "s/__BITCOIN_MAINNET_RPC_PASS__/${__BITCOIN_MAINNET_RPC_PASS__}/g" mempool-config.json
+sed -i "s/__ELECTRS_MAINNET_HTTP_HOST__/${__ELECTRS_MAINNET_HTTP_HOST__}/g" mempool-config.json
+sed -i "s/__ELECTRS_MAINNET_HTTP_PORT__/${__ELECTRS_MAINNET_HTTP_PORT__}/g" mempool-config.json
+sed -i "s/__MYSQL_HOST__/${__MYSQL_HOST__}/g" mempool-config.json
+sed -i "s/__MYSQL_PORT__/${__MYSQL_PORT__}/g" mempool-config.json
+sed -i "s/__MYSQL_DATABASE__/${__MYSQL_DATABASE__}/g" mempool-config.json
+sed -i "s/__MYSQL_USERNAME__/${__MYSQL_USERNAME__}/g" mempool-config.json
+sed -i "s/__MYSQL_PASSWORD__/${__MYSQL_PASSWORD__}/g" mempool-config.json
+sed -i "s!__MEMPOOL_BACKEND_MAINNET_CACHE_DIR__!${__MEMPOOL_BACKEND_MAINNET_CACHE_DIR__}!g" mempool-config.json
+sed -i "s/__MEMPOOL_BACKEND_MAINNET_HTTP_PORT__/${__MEMPOOL_BACKEND_MAINNET_HTTP_PORT__}/g" mempool-config.json
+
+node /backend/dist/index.js

docker/backend/wait-for-it.sh

@@ -0,0 +1,182 @@
+#!/usr/bin/env bash
+# Use this script to test if a given TCP host/port are available
+
+WAITFORIT_cmdname=${0##*/}
+
+echoerr() { if [[ $WAITFORIT_QUIET -ne 1 ]]; then echo "$@" 1>&2; fi }
+
+usage()
+{
+    cat << USAGE >&2
+Usage:
+    $WAITFORIT_cmdname host:port [-s] [-t timeout] [-- command args]
+    -h HOST | --host=HOST       Host or IP under test
+    -p PORT | --port=PORT       TCP port under test
+                                Alternatively, you specify the host and port as host:port
+    -s | --strict               Only execute subcommand if the test succeeds
+    -q | --quiet                Don't output any status messages
+    -t TIMEOUT | --timeout=TIMEOUT
+                                Timeout in seconds, zero for no timeout
+    -- COMMAND ARGS             Execute command with args after the test finishes
+USAGE
+    exit 1
+}
+
+wait_for()
+{
+    if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then
+        echoerr "$WAITFORIT_cmdname: waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT"
+    else
+        echoerr "$WAITFORIT_cmdname: waiting for $WAITFORIT_HOST:$WAITFORIT_PORT without a timeout"
+    fi
+    WAITFORIT_start_ts=$(date +%s)
+    while :
+    do
+        if [[ $WAITFORIT_ISBUSY -eq 1 ]]; then
+            nc -z $WAITFORIT_HOST $WAITFORIT_PORT
+            WAITFORIT_result=$?
+        else
+            (echo -n > /dev/tcp/$WAITFORIT_HOST/$WAITFORIT_PORT) >/dev/null 2>&1
+            WAITFORIT_result=$?
+        fi
+        if [[ $WAITFORIT_result -eq 0 ]]; then
+            WAITFORIT_end_ts=$(date +%s)
+            echoerr "$WAITFORIT_cmdname: $WAITFORIT_HOST:$WAITFORIT_PORT is available after $((WAITFORIT_end_ts - WAITFORIT_start_ts)) seconds"
+            break
+        fi
+        sleep 1
+    done
+    return $WAITFORIT_result
+}
+
+wait_for_wrapper()
+{
+    # In order to support SIGINT during timeout: http://unix.stackexchange.com/a/57692
+    if [[ $WAITFORIT_QUIET -eq 1 ]]; then
+        timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --quiet --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT &
+    else
+        timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT &
+    fi
+    WAITFORIT_PID=$!
+    trap "kill -INT -$WAITFORIT_PID" INT
+    wait $WAITFORIT_PID
+    WAITFORIT_RESULT=$?
+    if [[ $WAITFORIT_RESULT -ne 0 ]]; then
+        echoerr "$WAITFORIT_cmdname: timeout occurred after waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT"
+    fi
+    return $WAITFORIT_RESULT
+}
+
+# process arguments
+while [[ $# -gt 0 ]]
+do
+    case "$1" in
+        *:* )
+        WAITFORIT_hostport=(${1//:/ })
+        WAITFORIT_HOST=${WAITFORIT_hostport[0]}
+        WAITFORIT_PORT=${WAITFORIT_hostport[1]}
+        shift 1
+        ;;
+        --child)
+        WAITFORIT_CHILD=1
+        shift 1
+        ;;
+        -q | --quiet)
+        WAITFORIT_QUIET=1
+        shift 1
+        ;;
+        -s | --strict)
+        WAITFORIT_STRICT=1
+        shift 1
+        ;;
+        -h)
+        WAITFORIT_HOST="$2"
+        if [[ $WAITFORIT_HOST == "" ]]; then break; fi
+        shift 2
+        ;;
+        --host=*)
+        WAITFORIT_HOST="${1#*=}"
+        shift 1
+        ;;
+        -p)
+        WAITFORIT_PORT="$2"
+        if [[ $WAITFORIT_PORT == "" ]]; then break; fi
+        shift 2
+        ;;
+        --port=*)
+        WAITFORIT_PORT="${1#*=}"
+        shift 1
+        ;;
+        -t)
+        WAITFORIT_TIMEOUT="$2"
+        if [[ $WAITFORIT_TIMEOUT == "" ]]; then break; fi
+        shift 2
+        ;;
+        --timeout=*)
+        WAITFORIT_TIMEOUT="${1#*=}"
+        shift 1
+        ;;
+        --)
+        shift
+        WAITFORIT_CLI=("$@")
+        break
+        ;;
+        --help)
+        usage
+        ;;
+        *)
+        echoerr "Unknown argument: $1"
+        usage
+        ;;
+    esac
+done
+
+if [[ "$WAITFORIT_HOST" == "" || "$WAITFORIT_PORT" == "" ]]; then
+    echoerr "Error: you need to provide a host and port to test."
+    usage
+fi
+
+WAITFORIT_TIMEOUT=${WAITFORIT_TIMEOUT:-15}
+WAITFORIT_STRICT=${WAITFORIT_STRICT:-0}
+WAITFORIT_CHILD=${WAITFORIT_CHILD:-0}
+WAITFORIT_QUIET=${WAITFORIT_QUIET:-0}
+
+# Check to see if timeout is from busybox?
+WAITFORIT_TIMEOUT_PATH=$(type -p timeout)
+WAITFORIT_TIMEOUT_PATH=$(realpath $WAITFORIT_TIMEOUT_PATH 2>/dev/null || readlink -f $WAITFORIT_TIMEOUT_PATH)
+
+WAITFORIT_BUSYTIMEFLAG=""
+if [[ $WAITFORIT_TIMEOUT_PATH =~ "busybox" ]]; then
+    WAITFORIT_ISBUSY=1
+    # Check if busybox timeout uses -t flag
+    # (recent Alpine versions don't support -t anymore)
+    if timeout &>/dev/stdout | grep -q -e '-t '; then
+        WAITFORIT_BUSYTIMEFLAG="-t"
+    fi
+else
+    WAITFORIT_ISBUSY=0
+fi
+
+if [[ $WAITFORIT_CHILD -gt 0 ]]; then
+    wait_for
+    WAITFORIT_RESULT=$?
+    exit $WAITFORIT_RESULT
+else
+    if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then
+        wait_for_wrapper
+        WAITFORIT_RESULT=$?
+    else
+        wait_for
+        WAITFORIT_RESULT=$?
+    fi
+fi
+
+if [[ $WAITFORIT_CLI != "" ]]; then
+    if [[ $WAITFORIT_RESULT -ne 0 && $WAITFORIT_STRICT -eq 1 ]]; then
+        echoerr "$WAITFORIT_cmdname: strict mode, refusing to execute subprocess"
+        exit $WAITFORIT_RESULT
+    fi
+    exec "${WAITFORIT_CLI[@]}"
+else
+    exit $WAITFORIT_RESULT
+fi

docker/frontend/Dockerfile

@@ -0,0 +1,34 @@
+FROM node:12-buster-slim AS builder
+
+WORKDIR /build
+COPY . .
+RUN apt-get update
+RUN apt-get install -y build-essential rsync
+RUN npm i
+RUN npm run build
+
+FROM nginx:1.17.8-alpine
+
+WORKDIR /patch
+
+COPY --from=builder /build/entrypoint.sh .
+COPY --from=builder /build/wait-for .
+COPY --from=builder /build/dist/mempool /var/www/mempool
+COPY --from=builder /build/nginx.conf /etc/nginx/
+COPY --from=builder /build/nginx-mempool.conf /etc/nginx/conf.d/
+
+RUN chmod +x /patch/entrypoint.sh
+RUN chmod +x /patch/wait-for
+
+RUN chown -R 1000:1000 /patch && chmod -R 755 /patch && \
+        chown -R 1000:1000 /var/cache/nginx && \
+        chown -R 1000:1000 /var/log/nginx && \
+        chown -R 1000:1000 /etc/nginx/nginx.conf && \
+        chown -R 1000:1000 /etc/nginx/conf.d
+RUN touch /var/run/nginx.pid && \
+        chown -R 1000:1000 /var/run/nginx.pid
+
+USER 1000
+
+ENTRYPOINT ["/patch/entrypoint.sh"]
+CMD ["nginx", "-g", "daemon off;"]

docker/frontend/entrypoint.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+__MEMPOOL_BACKEND_MAINNET_HTTP_HOST__=${BACKEND_MAINNET_HTTP_HOST:=127.0.0.1}
+__MEMPOOL_BACKEND_MAINNET_HTTP_PORT__=${BACKEND_MAINNET_HTTP_PORT:=8999}
+__MEMPOOL_FRONTEND_HTTP_PORT__=${FRONTEND_HTTP_PORT:=8080}
+
+sed -i "s/__MEMPOOL_BACKEND_MAINNET_HTTP_HOST__/${__MEMPOOL_BACKEND_MAINNET_HTTP_HOST__}/g" /etc/nginx/conf.d/nginx-mempool.conf
+sed -i "s/__MEMPOOL_BACKEND_MAINNET_HTTP_PORT__/${__MEMPOOL_BACKEND_MAINNET_HTTP_PORT__}/g" /etc/nginx/conf.d/nginx-mempool.conf
+
+cp /etc/nginx/nginx.conf /patch/nginx.conf
+sed -i "s/__MEMPOOL_FRONTEND_HTTP_PORT__/${__MEMPOOL_FRONTEND_HTTP_PORT__}/g" /patch/nginx.conf
+cat /patch/nginx.conf > /etc/nginx/nginx.conf
+
+exec "$@"

docker/frontend/wait-for

@@ -0,0 +1,84 @@
+#!/bin/sh
+
+TIMEOUT=15
+QUIET=0
+
+echoerr() {
+  if [ "$QUIET" -ne 1 ]; then printf "%s\n" "$*" 1>&2; fi
+}
+
+usage() {
+  exitcode="$1"
+  cat << USAGE >&2
+Usage:
+  $cmdname host:port [-t timeout] [-- command args]
+  -q | --quiet                        Do not output any status messages
+  -t TIMEOUT | --timeout=timeout      Timeout in seconds, zero for no timeout
+  -- COMMAND ARGS                     Execute command with args after the test finishes
+USAGE
+  exit "$exitcode"
+}
+
+wait_for() {
+ if ! command -v nc >/dev/null; then
+    echoerr 'nc command is missing!'
+    exit 1
+  fi
+
+  for i in `seq $TIMEOUT` ; do
+    nc -z "$HOST" "$PORT" > /dev/null 2>&1
+    
+    result=$?
+    if [ $result -eq 0 ] ; then
+      if [ $# -gt 0 ] ; then
+        exec "$@"
+      fi
+      exit 0
+    fi
+    sleep 1
+  done
+  echo "Operation timed out" >&2
+  exit 1
+}
+
+while [ $# -gt 0 ]
+do
+  case "$1" in
+    *:* )
+    HOST=$(printf "%s\n" "$1"| cut -d : -f 1)
+    PORT=$(printf "%s\n" "$1"| cut -d : -f 2)
+    shift 1
+    ;;
+    -q | --quiet)
+    QUIET=1
+    shift 1
+    ;;
+    -t)
+    TIMEOUT="$2"
+    if [ "$TIMEOUT" = "" ]; then break; fi
+    shift 2
+    ;;
+    --timeout=*)
+    TIMEOUT="${1#*=}"
+    shift 1
+    ;;
+    --)
+    shift
+    break
+    ;;
+    --help)
+    usage 0
+    ;;
+    *)
+    echoerr "Unknown argument: $1"
+    usage 1
+    ;;
+  esac
+done
+
+if [ "$HOST" = "" -o "$PORT" = "" ]; then
+  echoerr "Error: you need to provide a host and port to test."
+  usage 2
+fi
+
+wait_for "$@"

docker/init.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+#backend
+gitMaster="\.\.\/\.git\/refs\/heads\/master"
+git ls-remote https://github.com/mempool/mempool.git $1 | awk '{ print $1}' > ./backend/master
+cp ./docker/backend/* ./backend/
+sed -i "s/${gitMaster}/master/g" ./backend/src/api/backend-info.ts
+
+#frontend
+localhostIP="127.0.0.1"
+cp ./docker/frontend/* ./frontend
+cp ./nginx.conf ./frontend/
+cp ./nginx-mempool.conf ./frontend/
+sed -i "s/${localhostIP}:80/0.0.0.0:__MEMPOOL_FRONTEND_HTTP_PORT__/g" ./frontend/nginx.conf
+sed -i "s/${localhostIP}/0.0.0.0/g" ./frontend/nginx.conf
+sed -i "s/user nobody;//g" ./frontend/nginx.conf
+sed -i "s!/etc/nginx/nginx-mempool.conf!/etc/nginx/conf.d/nginx-mempool.conf!g" ./frontend/nginx.conf
+sed -i "s/${localhostIP}:8999/__MEMPOOL_BACKEND_MAINNET_HTTP_HOST__:__MEMPOOL_BACKEND_MAINNET_HTTP_PORT__/g" ./frontend/nginx-mempool.conf

entrypoint.sh

@@ -1,51 +0,0 @@
-#!/bin/bash
-## Start SQL
-mysqld_safe&
-sleep 5
-## http server:
-nginx
-
-## Set up some files:
-cd /mempool.space/backend 
-rm -f cache.json
-touch cache.json
-
-## Build mempool-config.json file ourseleves.
-## We used to use jq for this but that produced output which caused bugs,
-## specifically numbers were surrounded by quotes, which breaks things.
-## Old command was jq -n env > mempool-config.json
-## This way is more complex, but more compatible with the backend functions.
-
-## Define a function to allow us to easily get indexes of the = string in from the env output:
-strindex() { 
-  x="${1%%$2*}"
-  [[ "$x" = "$1" ]] && echo -1 || echo "${#x}"
-}
-## Regex to check if we have a number or not:
-NumberRegEx='^[0-9]+$'
-## Delete the old file, and start a new one:
-rm -f mempool-config.json
-echo "{" >> mempool-config.json
-## For each env we add into the mempool-config.json file in one of two ways.
-## Either:
-## "Variable": "Value",
-## if a string, or
-## "Variable": Value,
-## if a integer
-for e in `env`; do
-    if [[ ${e:`strindex "$e" "="`+1} =~ $NumberRegEx ]] ; then
-        ## Integer add:
-        echo "\""${e:0:`strindex "$e" "="`}"\": "${e:`strindex "$e" "="`+1}","  >> mempool-config.json
-    else
-        ## String add:
-        echo "\""${e:0:`strindex "$e" "="`}"\": \""${e:`strindex "$e" "="`+1}$"\","  >> mempool-config.json
-    fi
-done
-## Take out the trailing , from the last entry.
-## This means replacing the file with one that is missing the last character
-echo `sed '$ s/.$//' mempool-config.json` > mempool-config.json
-## And finally finish off:
-echo "}" >> mempool-config.json
-
-## Start mempoolspace:
-node dist/index.js

frontend/.browserslistrc

@@ -0,0 +1,12 @@
+# This file is used by the build system to adjust CSS and JS output to support the specified browsers below.
+# For additional information regarding the format and rule options, please see:
+# https://github.com/browserslist/browserslist#queries
+
+# You can see what browsers were selected by your queries by running:
+#   npx browserslist
+
+> 0.5%
+last 2 versions
+Firefox ESR
+not dead
+not IE 9-11 # For IE 9-11 support, remove 'not'.

frontend/.editorconfig

@@ -1,4 +1,4 @@
-# Editor configuration, see http://editorconfig.org
+# Editor configuration, see https://editorconfig.org
 root = true
 
 [*]

frontend/.gitignore

@@ -4,10 +4,18 @@
 /dist
 /tmp
 /out-tsc
+server.run.js
+
+# Only exists if Bazel was run
+/bazel-out
 
 # dependencies
 /node_modules
 
+# profiling files
+chrome-profiler-events.json
+speed-measure-plugin.json
+
 # IDEs and editors
 /.idea
 .project
@@ -23,6 +31,7 @@
 !.vscode/tasks.json
 !.vscode/launch.json
 !.vscode/extensions.json
+.history/*
 
 # misc
 /.sass-cache
@@ -37,3 +46,11 @@ testem.log
 # System Files
 .DS_Store
 Thumbs.db
+
+src/resources/assets.json
+src/resources/assets.minimal.json
+src/resources/pools.json
+
+# environment config
+mempool-frontend-config.json
+generated-config.js

frontend/.tx/config

@@ -0,0 +1,7 @@
+[main]
+host = https://www.transifex.com
+
+[mempool.frontend-src-locale-messages-xlf--master]
+file_filter = frontend/src/locale/messages.<lang>.xlf
+source_lang = en-US
+type = XLIFF

frontend/README.md

@@ -0,0 +1,31 @@
+# mempool-frontend
+
+## Transifex Project
+
+The mempool frontend strings are localized into 20+ locales:
+https://www.transifex.com/mempool/mempool/dashboard/
+
+## Translators
+
+* Arabic @baro0k
+* Czech @pixelmade2
+* German @Emzy
+* English (default)
+* Spanish @maxhodler @bisqes
+* Persian @techmix
+* French @Bayernatoor
+* Korean @kcalvinalvinn
+* Italian @HodlBits
+* Georgian @wyd_idk
+* Hungarian @btcdragonlord
+* Dutch @m__btc
+* Japanese @wiz @japananon
+* Norwegian @T82771355
+* Portugese @jgcastro1985
+* Slovenian @thepkbadger
+* Finnish @bio_bitcoin
+* Swedish @softsimon_
+* Turkish @stackmore
+* Ukrainian @volbil
+* Vietnamese @bitcoin_vietnam
+* Chinese @wdljt

frontend/angular.json

@@ -4,32 +4,129 @@
   "newProjectRoot": "projects",
   "projects": {
     "mempool": {
-      "root": "",
-      "sourceRoot": "src",
       "projectType": "application",
-      "prefix": "app",
       "schematics": {
         "@schematics/angular:component": {
-          "styleext": "scss"
+          "style": "scss"
+        }
+      },
+      "root": "",
+      "sourceRoot": "src",
+      "prefix": "app",
+      "i18n": {
+        "sourceLocale": {
+          "code":"en-US",
+          "baseHref":"/"
+        },
+        "locales": {
+          "ar": {
+            "translation": "src/locale/messages.ar.xlf",
+            "baseHref": "/ar/"
+          },
+          "cs": {
+            "translation": "src/locale/messages.cs.xlf",
+            "baseHref": "/cs/"
+          },
+          "de": {
+            "translation": "src/locale/messages.de.xlf",
+            "baseHref": "/de/"
+          },
+          "es": {
+            "translation": "src/locale/messages.es.xlf",
+            "baseHref": "/es/"
+          },
+          "fa": {
+            "translation": "src/locale/messages.fa.xlf",
+            "baseHref": "/fa/"
+          },
+          "fr": {
+            "translation": "src/locale/messages.fr.xlf",
+            "baseHref": "/fr/"
+          },
+          "ja": {
+            "translation": "src/locale/messages.ja.xlf",
+            "baseHref": "/ja/"
+          },
+          "ka": {
+            "translation": "src/locale/messages.ka.xlf",
+            "baseHref": "/ka/"
+          },
+          "ko": {
+            "translation": "src/locale/messages.ko.xlf",
+            "baseHref": "/ko/"
+          },
+          "it": {
+            "translation": "src/locale/messages.it.xlf",
+            "baseHref": "/it/"
+          },
+          "nl": {
+            "translation": "src/locale/messages.nl.xlf",
+            "baseHref": "/nl/"
+          },
+          "nb": {
+            "translation": "src/locale/messages.nb.xlf",
+            "baseHref": "/nb/"
+          },
+          "pt": {
+            "translation": "src/locale/messages.pt.xlf",
+            "baseHref": "/pt/"
+          },
+          "sl": {
+            "translation": "src/locale/messages.sl.xlf",
+            "baseHref": "/sl/"
+          },
+          "sv": {
+            "translation": "src/locale/messages.sv.xlf",
+            "baseHref": "/sv/"
+          },
+          "tr": {
+            "translation": "src/locale/messages.tr.xlf",
+            "baseHref": "/tr/"
+          },
+          "uk": {
+            "translation": "src/locale/messages.uk.xlf",
+            "baseHref": "/uk/"
+          },
+          "fi": {
+            "translation": "src/locale/messages.fi.xlf",
+            "baseHref": "/fi/"
+          },
+          "vi": {
+            "translation": "src/locale/messages.vi.xlf",
+            "baseHref": "/vi/"
+          },
+          "hu": {
+            "translation": "src/locale/messages.hu.xlf",
+            "baseHref": "/hu/"
+          },
+          "zh": {
+            "translation": "src/locale/messages.zh.xlf",
+            "baseHref": "/zh/"
+          }
         }
       },
       "architect": {
         "build": {
           "builder": "@angular-devkit/build-angular:browser",
           "options": {
-            "outputPath": "dist/mempool",
+            "outputPath": "dist/mempool/browser",
             "index": "src/index.html",
             "main": "src/main.ts",
             "polyfills": "src/polyfills.ts",
-            "tsConfig": "src/tsconfig.app.json",
+            "tsConfig": "tsconfig.app.json",
+            "aot": true,
             "assets": [
               "src/favicon.ico",
-              "src/assets"
+              "src/resources",
+              "src/robots.txt"
             ],
             "styles": [
-              "src/styles.scss"
+              "src/styles.scss",
+              "node_modules/@fortawesome/fontawesome-svg-core/styles.css"
             ],
-            "scripts": []
+            "scripts": [
+              "generated-config.js"
+            ]
           },
           "configurations": {
             "production": {
@@ -44,27 +141,20 @@
               "sourceMap": false,
               "extractCss": true,
               "namedChunks": false,
-              "aot": true,
               "extractLicenses": true,
               "vendorChunk": false,
-              "buildOptimizer": true
-            },
-            "electrs": {
-              "fileReplacements": [
+              "buildOptimizer": true,
+              "budgets": [
                 {
-                  "replace": "src/environments/environment.ts",
-                  "with": "src/environments/environment-electrs.prod.ts"
+                  "type": "initial",
+                  "maximumWarning": "2mb",
+                  "maximumError": "5mb"
+                },
+                {
+                  "type": "anyComponentStyle",
+                  "maximumWarning": "6kb"
                 }
-              ],
-              "optimization": true,
-              "outputHashing": "all",
-              "sourceMap": false,
-              "extractCss": true,
-              "namedChunks": false,
-              "aot": true,
-              "extractLicenses": true,
-              "vendorChunk": false,
-              "buildOptimizer": true
+              ]
             }
           }
         },
@@ -90,54 +180,93 @@
           "options": {
             "main": "src/test.ts",
             "polyfills": "src/polyfills.ts",
-            "tsConfig": "src/tsconfig.spec.json",
-            "karmaConfig": "src/karma.conf.js",
+            "tsConfig": "tsconfig.spec.json",
+            "karmaConfig": "karma.conf.js",
+            "assets": [
+              "src/favicon.ico",
+              "src/resources"
+            ],
             "styles": [
               "src/styles.scss"
             ],
-            "scripts": [],
-            "assets": [
-              "src/favicon.ico",
-              "src/assets"
-            ]
+            "scripts": []
           }
         },
         "lint": {
           "builder": "@angular-devkit/build-angular:tslint",
           "options": {
             "tsConfig": [
-              "src/tsconfig.app.json",
-              "src/tsconfig.spec.json"
+              "tsconfig.app.json",
+              "tsconfig.spec.json",
+              "e2e/tsconfig.json",
+              "tsconfig.server.json"
             ],
             "exclude": [
               "**/node_modules/**"
             ]
           }
-        }
-      }
-    },
-    "mempool-e2e": {
-      "root": "e2e/",
-      "projectType": "application",
-      "architect": {
+        },
         "e2e": {
           "builder": "@angular-devkit/build-angular:protractor",
           "options": {
             "protractorConfig": "e2e/protractor.conf.js",
             "devServerTarget": "mempool:serve"
+          },
+          "configurations": {
+            "production": {
+              "devServerTarget": "mempool:serve:production"
+            }
           }
         },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
+        "server": {
+          "builder": "@angular-devkit/build-angular:server",
           "options": {
-            "tsConfig": "e2e/tsconfig.e2e.json",
-            "exclude": [
-              "**/node_modules/**"
+            "outputPath": "dist/mempool/server",
+            "main": "server.ts",
+            "tsConfig": "tsconfig.server.json"
+          },
+          "configurations": {
+            "production": {
+              "outputHashing": "media",
+              "fileReplacements": [
+                {
+                  "replace": "src/environments/environment.ts",
+                  "with": "src/environments/environment.prod.ts"
+                }
+              ],
+              "sourceMap": false,
+              "localize": true,
+              "optimization": true
+            }
+          }
+        },
+        "serve-ssr": {
+          "builder": "@nguniversal/builders:ssr-dev-server",
+          "options": {
+            "browserTarget": "mempool:build",
+            "serverTarget": "mempool:server"
+          },
+          "configurations": {
+            "production": {
+              "browserTarget": "mempool:build:production",
+              "serverTarget": "mempool:server:production"
+            }
+          }
+        },
+        "prerender": {
+          "builder": "@nguniversal/builders:prerender",
+          "options": {
+            "browserTarget": "mempool:build:production",
+            "serverTarget": "mempool:server:production",
+            "routes": [
+              "/"
             ]
+          },
+          "configurations": {
+            "production": {}
           }
         }
       }
-    }
-  },
+    }},
   "defaultProject": "mempool"
 }

frontend/e2e/protractor.conf.js

@@ -1,8 +1,12 @@
+// @ts-check
 // Protractor configuration file, see link for more information
 // https://github.com/angular/protractor/blob/master/lib/config.ts
 
 const { SpecReporter } = require('jasmine-spec-reporter');
 
+/**
+ * @type { import("protractor").Config }
+ */
 exports.config = {
   allScriptsTimeout: 11000,
   specs: [
@@ -21,7 +25,7 @@ exports.config = {
   },
   onPrepare() {
     require('ts-node').register({
-      project: require('path').join(__dirname, './tsconfig.e2e.json')
+      project: require('path').join(__dirname, './tsconfig.json')
     });
     jasmine.getEnv().addReporter(new SpecReporter({ spec: { displayStacktrace: true } }));
   }

frontend/e2e/src/app.e2e-spec.ts

@@ -1,4 +1,5 @@
 import { AppPage } from './app.po';
+import { browser, logging } from 'protractor';
 
 describe('workspace-project App', () => {
   let page: AppPage;
@@ -9,6 +10,14 @@ describe('workspace-project App', () => {
 
   it('should display welcome message', () => {
     page.navigateTo();
-    expect(page.getParagraphText()).toEqual('Welcome to app!');
+    expect(page.getTitleText()).toEqual('Welcome to mempool!');
+  });
+
+  afterEach(async () => {
+    // Assert that there are no errors emitted from the browser
+    const logs = await browser.manage().logs().get(logging.Type.BROWSER);
+    expect(logs).not.toContain(jasmine.objectContaining({
+      level: logging.Level.SEVERE,
+    } as logging.Entry));
   });
 });

frontend/e2e/src/app.po.ts

@@ -2,10 +2,10 @@ import { browser, by, element } from 'protractor';
 
 export class AppPage {
   navigateTo() {
-    return browser.get('/');
+    return browser.get(browser.baseUrl) as Promise<any>;
   }
 
-  getParagraphText() {
-    return element(by.css('app-root h1')).getText();
+  getTitleText() {
+    return element(by.css('app-root h1')).getText() as Promise<string>;
   }
 }

frontend/e2e/tsconfig.json

@@ -1,13 +1,13 @@
 {
-  "extends": "../tsconfig.json",
+  "extends": "../tsconfig.base.json",
   "compilerOptions": {
-    "outDir": "../out-tsc/app",
+    "outDir": "../out-tsc/e2e",
     "module": "commonjs",
-    "target": "es5",
+    "target": "es2018",
     "types": [
       "jasmine",
       "jasminewd2",
       "node"
     ]
   }
-}
+}

frontend/frontend

@@ -0,0 +1 @@
+.

frontend/generate-config.js

@@ -0,0 +1,36 @@
+var fs = require('fs');
+
+const CONFIG_FILE_NAME = 'mempool-frontend-config.json';
+const GENERATED_CONFIG_FILE_NAME = 'generated-config.js';
+
+let settings = [];
+let configContent = {};
+
+try {
+  const rawConfig = fs.readFileSync(CONFIG_FILE_NAME);
+  configContent = JSON.parse(rawConfig);
+} catch (e) {
+  if (e.code !== 'ENOENT') {
+    throw new Error(e);
+  }
+}
+
+for (setting in configContent) {
+  settings.push({
+    key: setting,
+    value: configContent[setting]
+  });
+}
+
+const code = `(function (window) {
+  window.__env = window.__env || {};${settings.reduce((str, obj) => `${str}
+    window.__env.${obj.key} = ${ typeof obj.value === 'string' ? `'${obj.value}'` : obj.value };`, '')}
+  }(global || this));`;
+
+try {
+  fs.writeFileSync(GENERATED_CONFIG_FILE_NAME, code, 'utf8');
+} catch (e) {
+  throw new Error(e);
+}
+
+console.log('Config file generated');

frontend/karma.conf.js

@@ -16,8 +16,8 @@ module.exports = function (config) {
       clearContext: false // leave Jasmine Spec Runner output visible in browser
     },
     coverageIstanbulReporter: {
-      dir: require('path').join(__dirname, '../coverage'),
-      reports: ['html', 'lcovonly'],
+      dir: require('path').join(__dirname, './coverage/mempool'),
+      reports: ['html', 'lcovonly', 'text-summary'],
       fixWebpackSourcePaths: true
     },
     reporters: ['progress', 'kjhtml'],
@@ -26,6 +26,7 @@ module.exports = function (config) {
     logLevel: config.LOG_INFO,
     autoWatch: true,
     browsers: ['Chrome'],
-    singleRun: false
+    singleRun: false,
+    restartOnFileChange: true
   });
-};
+};

frontend/mempool-frontend-config.sample.json

@@ -0,0 +1,11 @@
+{
+  "TESTNET_ENABLED": false,
+  "LIQUID_ENABLED": false,
+  "BISQ_ENABLED": false,
+  "BISQ_SEPARATE_BACKEND": false,
+  "ITEMS_PER_PAGE": 10,
+  "KEEP_BLOCKS_AMOUNT": 8,
+  "NGINX_PROTOCOL": "http",
+  "NGINX_HOSTNAME": "127.0.0.1",
+  "NGINX_PORT": "80"
+}

frontend/package.json

@@ -1,50 +1,96 @@
 {
   "name": "mempool-frontend",
-  "version": "1.0.0",
-  "description": "Bitcoin Mempool Visualizer",
+  "version": "2.1.2",
+  "description": "Bitcoin mempool visualizer and blockchain explorer backend",
+  "license": "MIT",
+  "homepage": "https://mempool.space",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mempool/mempool"
+  },
+  "bugs": {
+    "url": "https://github.com/mempool/mempool/issues"
+  },
+  "keywords": [
+    "bitcoin",
+    "mempool",
+    "blockchain",
+    "explorer",
+    "liquid"
+  ],
+  "main": "index.ts",
   "scripts": {
-    "ng": "ng",
-    "start": "ng serve --aot --proxy-config proxy.conf.json",
-    "build": "ng build --prod",
-    "build-electrs": "ng build --prod --configuration=electrs",
+    "ng": "./node_modules/@angular/cli/bin/ng",
+    "tsc": "./node_modules/typescript/bin/tsc",
+    "i18n-extract-from-source": "./node_modules/@angular/cli/bin/ng xi18n --ivy --out-file ./src/locale/messages.xlf",
+    "i18n-pull-from-transifex": "tx pull -a --parallel --minimum-perc 1 --force",
+    "serve": "ng serve --proxy-config proxy.conf.json",
+    "start": "npm run generate-config && npm run sync-assets-dev && ng serve --proxy-config proxy.conf.json",
+    "build": "npm run generate-config && ng build --prod --localize && npm run sync-assets",
+    "sync-assets": "node sync-assets.js && rsync -av ./dist/mempool/browser/en-US/resources ./dist/mempool/browser/resources",
+    "sync-assets-dev": "node sync-assets.js dev",
+    "generate-config": "node generate-config.js",
     "test": "ng test",
     "lint": "ng lint",
-    "e2e": "ng e2e"
+    "e2e": "ng e2e",
+    "dev:ssr": "npm run generate-config && ng run mempool:serve-ssr",
+    "serve:ssr": "node server.run.js",
+    "build:ssr": "npm run build && ng run mempool:server:production && ./node_modules/typescript/bin/tsc server.run.ts",
+    "prerender": "ng run mempool:prerender"
   },
-  "author": {
-    "name": "Simon Lindh",
-    "url": "https://github.com/mempool-space/mempool.space"
-  },
-  "license": "MIT",
   "dependencies": {
-    "@angular/animations": "^8.2.11",
-    "@angular/common": "^8.2.11",
-    "@angular/compiler": "^8.2.11",
-    "@angular/core": "^8.2.11",
-    "@angular/forms": "^8.2.11",
-    "@angular/platform-browser": "^8.2.11",
-    "@angular/platform-browser-dynamic": "^8.2.11",
-    "@angular/router": "^8.2.11",
-    "@ng-bootstrap/ng-bootstrap": "^5.1.1",
-    "angularx-qrcode": "^1.7.0-beta.5",
-    "bootstrap": "^4.3.1",
-    "chartist": "^0.11.2",
-    "core-js": "^3.4.1",
-    "ng-chartist": "^2.0.0-beta.1",
-    "rxjs": "^6.5.3",
-    "tslib": "^1.9.0",
-    "zone.js": "~0.10.2"
+    "@angular/animations": "~10.2.3",
+    "@angular/common": "~10.2.3",
+    "@angular/compiler": "~10.2.3",
+    "@angular/core": "~10.2.3",
+    "@angular/forms": "~10.2.3",
+    "@angular/localize": "^10.2.3",
+    "@angular/platform-browser": "~10.2.3",
+    "@angular/platform-browser-dynamic": "~10.2.3",
+    "@angular/platform-server": "~10.2.2",
+    "@angular/router": "~10.2.3",
+    "@fortawesome/angular-fontawesome": "^0.7.0",
+    "@fortawesome/fontawesome-common-types": "^0.2.30",
+    "@fortawesome/fontawesome-svg-core": "^1.2.30",
+    "@fortawesome/free-solid-svg-icons": "^5.14.0",
+    "@mempool/chartist": "^0.11.4",
+    "@ng-bootstrap/ng-bootstrap": "^7.0.0",
+    "@nguniversal/express-engine": "10.1.0",
+    "@types/qrcode": "^1.3.4",
+    "bootstrap": "4.5.0",
+    "clipboard": "^2.0.4",
+    "domino": "^2.1.6",
+    "express": "^4.15.2",
+    "ngx-bootrap-multiselect": "^2.0.0",
+    "ngx-infinite-scroll": "^9.0.0",
+    "qrcode": "^1.4.4",
+    "rxjs": "^6.6.3",
+    "tlite": "^0.1.9",
+    "tslib": "^2.0.0",
+    "zone.js": "~0.10.3"
   },
   "devDependencies": {
-    "@angular-devkit/build-angular": "~0.800.0",
-    "@angular/cli": "~8.3.12",
-    "@angular/compiler-cli": "^8.2.11",
-    "@angular/language-service": "^8.2.11",
-    "@types/chartist": "^0.9.46",
-    "@types/node": "~8.9.4",
-    "codelyzer": "~5.1.0",
+    "@angular-devkit/build-angular": "^0.1002.0",
+    "@angular/cli": "~10.2.0",
+    "@angular/compiler-cli": "~10.2.2",
+    "@angular/language-service": "~10.2.2",
+    "@nguniversal/builders": "^10.1.0",
+    "@types/express": "^4.17.0",
+    "@types/jasmine": "~3.3.8",
+    "@types/jasminewd2": "~2.0.3",
+    "@types/node": "^12.11.1",
+    "codelyzer": "^6.0.0",
+    "http-proxy-middleware": "^1.0.5",
+    "jasmine-core": "~3.5.0",
+    "jasmine-spec-reporter": "~5.0.0",
+    "karma": "~5.0.0",
+    "karma-chrome-launcher": "~3.1.0",
+    "karma-coverage-istanbul-reporter": "~3.0.2",
+    "karma-jasmine": "~3.3.0",
+    "karma-jasmine-html-reporter": "^1.5.0",
+    "protractor": "~7.0.0",
     "ts-node": "~7.0.0",
-    "tslint": "~5.15.0",
-    "typescript": "~3.4.3"
+    "tslint": "~6.1.0",
+    "typescript": "~4.0.5"
   }
 }

frontend/proxy.conf.json

@@ -1,11 +1,74 @@
 {
-  "/api": {
+  "/api/v1/donations": {
+    "target": "http://localhost:9000/",
+    "secure": false
+  },
+  "/api/v1": {
     "target": "http://localhost:8999/",
     "secure": false
   },
-  "/ws": {
+  "/api/v1/ws": {
     "target": "http://localhost:8999/",
     "secure": false,
     "ws": true
+  },
+  "/api/": {
+    "target": "http://localhost:8999/",
+    "secure": false,
+    "pathRewrite": {
+      "^/api/": "/api/v1/"
+    }
+  },
+  "/testnet/api/v1": {
+    "target": "http://localhost:8999/",
+    "secure": false,
+    "pathRewrite": {
+      "^/testnet/api/v1": "/api/v1"
+    }
+  },
+  "/testnet/api/v1/ws": {
+    "target": "http://localhost:8999/",
+    "secure": false,
+    "ws": true,
+    "pathRewrite": {
+      "^/testnet/api": "/api/v1/ws"
+    }
+  },
+  "/testnet/api/": {
+    "target": "http://localhost:50001/",
+    "secure": false,
+    "pathRewrite": {
+      "^/testnet/api": ""
+    }
+  },
+  "/liquid/api/v1/ws": {
+    "target": "http://localhost:8999/",
+    "secure": false,
+    "ws": true,
+    "pathRewrite": {
+      "^/liquid/api": "/api/v1/ws"
+    }
+  },
+  "/liquid/api/": {
+    "target": "http://localhost:50001/",
+    "secure": false,
+    "pathRewrite": {
+      "^/liquid/api/": ""
+    }
+  },
+  "/bisq/api/": {
+    "target": "http://localhost:8999/",
+    "secure": false,
+    "pathRewrite": {
+      "^/bisq/api/": "/api/v1/bisq/"
+    }
+  },
+  "/bisq/api/v1/ws": {
+    "target": "http://localhost:8999/",
+    "secure": false,
+    "ws": true,
+    "pathRewrite": {
+      "^/bisq/api": "/api/v1/ws"
+    }
   }
 }

frontend/server.run.ts

@@ -0,0 +1,96 @@
+import 'zone.js/dist/zone-node';
+import './generated-config';
+
+import * as domino from 'domino';
+import * as express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const {readFileSync, existsSync} = require('fs');
+const {createProxyMiddleware} = require('http-proxy-middleware');
+
+const template = fs.readFileSync(path.join(process.cwd(), 'dist/mempool/browser/en-US/', 'index.html')).toString();
+const win = domino.createWindow(template);
+
+// @ts-ignore
+win.__env = global.__env;
+
+// @ts-ignore
+win.matchMedia = () => {
+  return {
+    matches: true
+  };
+};
+
+// @ts-ignore
+win.setTimeout = (fn) => { fn(); };
+win.document.body.scrollTo = (() => {});
+// @ts-ignore
+global['window'] = win;
+global['document'] = win.document;
+// @ts-ignore
+global['history'] = { state: { } };
+
+global['localStorage'] = {
+  getItem: () => '',
+  setItem: () => {},
+  removeItem: () => {},
+  clear: () => {},
+  length: 0,
+  key: () => '',
+};
+
+/**
+ * Return the list of supported and actually active locales
+ */
+function getActiveLocales() {
+  const angularConfig = JSON.parse(readFileSync('angular.json', 'utf8'));
+
+  const supportedLocales = [
+    angularConfig.projects.mempool.i18n.sourceLocale,
+    ...Object.keys(angularConfig.projects.mempool.i18n.locales),
+  ];
+
+  return supportedLocales.filter(locale => existsSync(`./dist/mempool/server/${locale}`));
+}
+
+function app() {
+  const server = express();
+
+  // proxy API to nginx
+  server.get('/api/**', createProxyMiddleware({
+    // @ts-ignore
+    target: win.__env.NGINX_PROTOCOL + '://' + win.__env.NGINX_HOSTNAME + ':' + win.__env.NGINX_PORT,
+    changeOrigin: true,
+  }));
+
+  // map / and /en to en-US
+  const defaultLocale = 'en-US';
+  console.log(`serving default locale: ${defaultLocale}`);
+  const appServerModule = require(`./dist/mempool/server/${defaultLocale}/main.js`);
+  server.use('/', appServerModule.app(defaultLocale));
+  server.use('/en', appServerModule.app(defaultLocale));
+
+  // map each locale to its localized main.js
+  getActiveLocales().forEach(locale => {
+    console.log('serving locale:', locale);
+    const appServerModule = require(`./dist/mempool/server/${locale}/main.js`);
+
+    // map everything to itself
+    server.use(`/${locale}`, appServerModule.app(locale));
+
+  });
+
+  return server;
+}
+
+function run() {
+  const port = process.env.PORT || 4000;
+
+  // Start up the Node server
+  app().listen(port, () => {
+    console.log(`Node Express server listening on port ${port}`);
+  });
+}
+
+run();

frontend/server.ts

@@ -0,0 +1,146 @@
+import 'zone.js/dist/zone-node';
+import './generated-config';
+
+import { ngExpressEngine } from '@nguniversal/express-engine';
+import * as express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as domino from 'domino';
+import { createProxyMiddleware } from 'http-proxy-middleware';
+
+import { join } from 'path';
+import { AppServerModule } from './src/main.server';
+import { APP_BASE_HREF } from '@angular/common';
+import { existsSync } from 'fs';
+
+const template = fs.readFileSync(path.join(process.cwd(), 'dist/mempool/browser/en-US/', 'index.html')).toString();
+const win = domino.createWindow(template);
+
+// @ts-ignore
+win.__env = global.__env;
+
+// @ts-ignore
+win.matchMedia = () => {
+  return {
+    matches: true
+  };
+};
+
+// @ts-ignore
+win.setTimeout = (fn) => { fn(); };
+win.document.body.scrollTo = (() => {});
+// @ts-ignore
+global['window'] = win;
+global['document'] = win.document;
+// @ts-ignore
+global['history'] = { state: { } };
+
+global['localStorage'] = {
+  getItem: () => '',
+  setItem: () => {},
+  removeItem: () => {},
+  clear: () => {},
+  length: 0,
+  key: () => '',
+};
+
+// The Express app is exported so that it can be used by serverless Functions.
+export function app(locale: string): express.Express {
+  const server = express();
+  const distFolder = join(process.cwd(), `dist/mempool/browser/${locale}`);
+  const indexHtml = existsSync(join(distFolder, 'index.original.html')) ? 'index.original.html' : 'index';
+
+  // Our Universal express-engine (found @ https://github.com/angular/universal/tree/master/modules/express-engine)
+  server.engine('html', ngExpressEngine({
+    bootstrap: AppServerModule,
+  }));
+
+  server.set('view engine', 'html');
+  server.set('views', distFolder);
+
+  // only handle URLs that actually exist
+  //server.get(locale, getLocalizedSSR(indexHtml));
+  server.get('/', getLocalizedSSR(indexHtml));
+  server.get('/tx/*', getLocalizedSSR(indexHtml));
+  server.get('/block/*', getLocalizedSSR(indexHtml));
+  server.get('/mempool-block/*', getLocalizedSSR(indexHtml));
+  server.get('/address/*', getLocalizedSSR(indexHtml));
+  server.get('/blocks', getLocalizedSSR(indexHtml));
+  server.get('/graphs', getLocalizedSSR(indexHtml));
+  server.get('/liquid', getLocalizedSSR(indexHtml));
+  server.get('/liquid/tx/*', getLocalizedSSR(indexHtml));
+  server.get('/liquid/block/*', getLocalizedSSR(indexHtml));
+  server.get('/liquid/mempool-block/*', getLocalizedSSR(indexHtml));
+  server.get('/liquid/address/*', getLocalizedSSR(indexHtml));
+  server.get('/liquid/asset/*', getLocalizedSSR(indexHtml));
+  server.get('/liquid/blocks', getLocalizedSSR(indexHtml));
+  server.get('/liquid/graphs', getLocalizedSSR(indexHtml));
+  server.get('/liquid/assets', getLocalizedSSR(indexHtml));
+  server.get('/liquid/api', getLocalizedSSR(indexHtml));
+  server.get('/liquid/tv', getLocalizedSSR(indexHtml));
+  server.get('/liquid/status', getLocalizedSSR(indexHtml));
+  server.get('/liquid/about', getLocalizedSSR(indexHtml));
+  server.get('/testnet', getLocalizedSSR(indexHtml));
+  server.get('/testnet/tx/*', getLocalizedSSR(indexHtml));
+  server.get('/testnet/block/*', getLocalizedSSR(indexHtml));
+  server.get('/testnet/mempool-block/*', getLocalizedSSR(indexHtml));
+  server.get('/testnet/address/*', getLocalizedSSR(indexHtml));
+  server.get('/testnet/blocks', getLocalizedSSR(indexHtml));
+  server.get('/testnet/graphs', getLocalizedSSR(indexHtml));
+  server.get('/testnet/api', getLocalizedSSR(indexHtml));
+  server.get('/testnet/tv', getLocalizedSSR(indexHtml));
+  server.get('/testnet/status', getLocalizedSSR(indexHtml));
+  server.get('/testnet/about', getLocalizedSSR(indexHtml));
+  server.get('/bisq', getLocalizedSSR(indexHtml));
+  server.get('/bisq/tx/*', getLocalizedSSR(indexHtml));
+  server.get('/bisq/blocks', getLocalizedSSR(indexHtml));
+  server.get('/bisq/block/*', getLocalizedSSR(indexHtml));
+  server.get('/bisq/address/*', getLocalizedSSR(indexHtml));
+  server.get('/bisq/stats', getLocalizedSSR(indexHtml));
+  server.get('/bisq/about', getLocalizedSSR(indexHtml));
+  server.get('/bisq/api', getLocalizedSSR(indexHtml));
+  server.get('/about', getLocalizedSSR(indexHtml));
+  server.get('/api', getLocalizedSSR(indexHtml));
+  server.get('/tv', getLocalizedSSR(indexHtml));
+  server.get('/status', getLocalizedSSR(indexHtml));
+  server.get('/terms-of-service', getLocalizedSSR(indexHtml));
+
+  // fallback to static file handler so we send HTTP 404 to nginx
+  server.get('/**', express.static(distFolder, { maxAge: '1y' }));
+
+  return server;
+}
+
+function getLocalizedSSR(indexHtml) {
+  return (req, res) => {
+    res.render(indexHtml, {
+      req,
+      providers: [
+        { provide: APP_BASE_HREF, useValue: req.baseUrl }
+      ]
+    });
+  }
+}
+
+// only used for development mode
+function run(): void {
+  const port = process.env.PORT || 4000;
+
+  // Start up the Node server
+  const server = app('en-US');
+  server.listen(port, () => {
+    console.log(`Node Express server listening on port ${port}`);
+  });
+}
+
+// Webpack will replace 'require' with '__webpack_require__'
+// '__non_webpack_require__' is a proxy to Node 'require'
+// The below code is to ensure that the server is run only when not requiring the bundle.
+declare const __non_webpack_require__: NodeRequire;
+const mainModule = __non_webpack_require__.main;
+const moduleFilename = mainModule && mainModule.filename || '';
+if (moduleFilename === __filename || moduleFilename.includes('iisnode')) {
+  run();
+}
+
+export * from './src/main.server';

frontend/src/app/about/about.component.html

@@ -1,42 +0,0 @@
-<div class="text-center">
-  <img src="./assets/mempool-tube.png" width="63" height="63" />
-  <br /><br />
-
-  <h2>About</h2>
-
-  <p>Mempool.Space is a realtime Bitcoin blockchain visualizer and statistics website focused on SegWit.</p>
-  <p>Created by <a href="http://t.me/softcrypto">@softcrypto</a> (Telegram). <a href="https://twitter.com/softcrypt0">@softcrypt0</a> (Twitter).
-  <br />Designed by <a href="https://emeraldo.io">emeraldo.io</a>.
-  <br />Hosted by <a href="https://twitter.com/wiz">@wiz</a></p>
-
-
-  <h2>Fee API</h2>
-
-  <div class="col-4 mx-auto">
-    <input class="form-control" type="text" value="https://mempool.space/api/v1/fees/recommended" readonly>
-  </div>
-
-  <br />
-
-  <h1>Donate</h1>
-  <h3>Segwit native</h3>
-  <img src="./assets/btc-qr-code-segwit.png" width="200" height="200" />
-  <br />
-  bc1qqrmgr60uetlmrpylhtllawyha9z5gw6hwdmk2t
-
-  <br /><br />
-  <h3>Segwit compatibility</h3>
-  <img src="./assets/btc-qr-code.png" width="200" height="200" />
-  <br />
-  3Ccig4G4u8hbExnxBJHeE5ZmxxWxvEQ65f
-
-
-  <br /><br />
-
-  <h3>PayNym</h3>
-  <img src="./assets/paynym-code.png" width="200" height="200" />
-  <br />
-  <p style="word-wrap: break-word; overflow-wrap: break-word;max-width: 300px; text-align: center; margin: auto;">
-    PM8TJZWDn1XbYmVVMR3RP9Kt1BW69VCSLTC12UB8iWUiKcEBJsxB4UUKBMJxc3LVaxtU5d524sLFrTy9kFuyPQ73QkEagGcMfCE6M38E5C67EF8KAqvS
-  </p>
-</div>

frontend/src/app/about/about.component.ts

@@ -1,19 +0,0 @@
-import { Component, OnInit } from '@angular/core';
-import { ApiService } from '../services/api.service';
-
-@Component({
-  selector: 'app-about',
-  templateUrl: './about.component.html',
-  styleUrls: ['./about.component.scss']
-})
-export class AboutComponent implements OnInit {
-
-  constructor(
-    private apiService: ApiService,
-  ) { }
-
-  ngOnInit() {
-    this.apiService.webSocketWant([]);
-  }
-
-}

frontend/src/app/app-routing.module.ts

@@ -1,10 +1,21 @@
 import { NgModule } from '@angular/core';
 import { Routes, RouterModule } from '@angular/router';
-import { BlockchainComponent } from './blockchain/blockchain.component';
-import { AboutComponent } from './about/about.component';
-import { StatisticsComponent } from './statistics/statistics.component';
-import { TelevisionComponent } from './television/television.component';
-import { MasterPageComponent } from './master-page/master-page.component';
+import { StartComponent } from './components/start/start.component';
+import { TransactionComponent } from './components/transaction/transaction.component';
+import { BlockComponent } from './components/block/block.component';
+import { AddressComponent } from './components/address/address.component';
+import { MasterPageComponent } from './components/master-page/master-page.component';
+import { AboutComponent } from './components/about/about.component';
+import { TelevisionComponent } from './components/television/television.component';
+import { StatisticsComponent } from './components/statistics/statistics.component';
+import { MempoolBlockComponent } from './components/mempool-block/mempool-block.component';
+import { AssetComponent } from './components/asset/asset.component';
+import { AssetsComponent } from './assets/assets.component';
+import { StatusViewComponent } from './components/status-view/status-view.component';
+import { DashboardComponent } from './dashboard/dashboard.component';
+import { LatestBlocksComponent } from './components/latest-blocks/latest-blocks.component';
+import { ApiDocsComponent } from './components/api-docs/api-docs.component';
+import { TermsOfServiceComponent } from './components/terms-of-service/terms-of-service.component';
 
 const routes: Routes = [
   {
@@ -13,44 +24,207 @@ const routes: Routes = [
     children: [
       {
         path: '',
-        children: [],
-        component: BlockchainComponent
+        component: StartComponent,
+        children: [
+          {
+            path: '',
+            component: DashboardComponent,
+          },
+          {
+            path: 'tx/:id',
+            component: TransactionComponent
+          },
+          {
+            path: 'block/:id',
+            component: BlockComponent
+          },
+          {
+            path: 'mempool-block/:id',
+            component: MempoolBlockComponent
+          },
+        ],
       },
       {
-        path: 'tx/:id',
-        children: [],
-        component: BlockchainComponent
-      },
-      {
-        path: 'about',
-        children: [],
-        component: AboutComponent
-      },
-      {
-        path: 'statistics',
-        component: StatisticsComponent,
+        path: 'blocks',
+        component: LatestBlocksComponent,
       },
       {
         path: 'graphs',
         component: StatisticsComponent,
       },
       {
-        path: 'explorer',
-        loadChildren: './explorer/explorer.module#ExplorerModule',
+        path: 'about',
+        component: AboutComponent,
+      },
+      {
+        path: 'api',
+        component: ApiDocsComponent,
+      },
+      {
+        path: 'terms-of-service',
+        component: TermsOfServiceComponent
+      },
+      {
+        path: 'address/:id',
+        children: [],
+        component: AddressComponent
       },
     ],
   },
+  {
+    path: 'liquid',
+    children: [
+      {
+        path: '',
+        component: MasterPageComponent,
+        children: [
+          {
+            path: '',
+            component: StartComponent,
+            children: [
+              {
+                path: '',
+                component: DashboardComponent
+              },
+              {
+                path: 'tx/:id',
+                component: TransactionComponent
+              },
+              {
+                path: 'block/:id',
+                component: BlockComponent
+              },
+              {
+                path: 'mempool-block/:id',
+                component: MempoolBlockComponent
+              },
+            ],
+          },
+          {
+            path: 'blocks',
+            component: LatestBlocksComponent,
+          },
+          {
+            path: 'graphs',
+            component: StatisticsComponent,
+          },
+          {
+            path: 'address/:id',
+            component: AddressComponent
+          },
+          {
+            path: 'asset/:id',
+            component: AssetComponent
+          },
+          {
+            path: 'assets',
+            component: AssetsComponent,
+          },
+          {
+            path: 'api',
+            component: ApiDocsComponent,
+          },
+        ],
+      },
+      {
+        path: 'tv',
+        component: TelevisionComponent
+      },
+      {
+        path: 'status',
+        component: StatusViewComponent
+      },
+      {
+        path: '**',
+        redirectTo: ''
+      },
+    ]
+  },
+  {
+    path: 'testnet',
+    children: [
+      {
+        path: '',
+        component: MasterPageComponent,
+        children: [
+          {
+            path: '',
+            component: StartComponent,
+            children: [
+              {
+                path: '',
+                component: DashboardComponent
+              },
+              {
+                path: 'tx/:id',
+                component: TransactionComponent
+              },
+              {
+                path: 'block/:id',
+                component: BlockComponent
+              },
+              {
+                path: 'mempool-block/:id',
+                component: MempoolBlockComponent
+              },
+            ],
+          },
+          {
+            path: 'blocks',
+            component: LatestBlocksComponent,
+          },
+          {
+            path: 'graphs',
+            component: StatisticsComponent,
+          },
+          {
+            path: 'address/:id',
+            children: [],
+            component: AddressComponent
+          },
+          {
+            path: 'api',
+            component: ApiDocsComponent,
+          },
+        ],
+      },
+      {
+        path: 'tv',
+        component: TelevisionComponent
+      },
+      {
+        path: 'status',
+        component: StatusViewComponent
+      },
+      {
+        path: '**',
+        redirectTo: ''
+      },
+    ]
+  },
+  {
+    path: 'bisq',
+    component: MasterPageComponent,
+    loadChildren: () => import('./bisq/bisq.module').then(m => m.BisqModule)
+  },
   {
     path: 'tv',
     component: TelevisionComponent,
   },
+  {
+    path: 'status',
+    component: StatusViewComponent
+  },
   {
     path: '**',
     redirectTo: ''
-  }
+  },
 ];
+
 @NgModule({
-  imports: [RouterModule.forRoot(routes)],
+  imports: [RouterModule.forRoot(routes, {
+    initialNavigation: 'enabled'
+})],
   exports: [RouterModule]
 })
 export class AppRoutingModule { }

frontend/src/app/app.component.html

@@ -1 +0,0 @@
-<router-outlet></router-outlet>

frontend/src/app/app.component.ts

@@ -1,10 +0,0 @@
-import { Component } from '@angular/core';
-
-@Component({
-  selector: 'app-root',
-  templateUrl: './app.component.html',
-  styleUrls: ['./app.component.scss']
-})
-export class AppComponent {
-  constructor() { }
-}

frontend/src/app/app.constants.ts

@@ -0,0 +1,90 @@
+export const mempoolFeeColors = [
+  '557d00',
+  '5d7d01',
+  '637d02',
+  '6d7d04',
+  '757d05',
+  '7d7d06',
+  '867d08',
+  '8c7d09',
+  '957d0b',
+  '9b7d0c',
+  'a67d0e',
+  'aa7d0f',
+  'b27d10',
+  'bb7d11',
+  'bf7d12',
+  'bf7815',
+  'bf7319',
+  'be6c1e',
+  'be6820',
+  'bd6125',
+  'bd5c28',
+  'bc552d',
+  'bc4f30',
+  'bc4a34',
+  'bb4339',
+  'bb3d3c',
+  'bb373f',
+  'ba3243',
+  'b92b48',
+  'b9254b',
+];
+
+export const feeLevels = [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];
+
+export interface Language {
+  code: string;
+  name: string;
+}
+
+export const languages: Language[] = [
+   { code: 'ar', name: 'العربية' },         // Arabic
+// { code: 'bg', name: 'Български' },       // Bulgarian
+// { code: 'bs', name: 'Bosanski' },        // Bosnian
+// { code: 'ca', name: 'Català' },          // Catalan
+   { code: 'cs', name: 'Čeština' },         // Czech
+// { code: 'da', name: 'Dansk' },           // Danish
+   { code: 'de', name: 'Deutsch' },         // German
+// { code: 'et', name: 'Eesti' },           // Estonian
+// { code: 'el', name: 'Ελληνικά' },        // Greek
+   { code: 'en', name: 'English' },         // English
+   { code: 'es', name: 'Español' },         // Spanish
+// { code: 'eo', name: 'Esperanto' },       // Esperanto
+// { code: 'eu', name: 'Euskara' },         // Basque
+   { code: 'fa', name: 'فارسی' },           // Persian
+   { code: 'fr', name: 'Français' },        // French
+// { code: 'gl', name: 'Galego' },          // Galician
+   { code: 'ko', name: '한국어' },          // Korean
+// { code: 'hr', name: 'Hrvatski' },        // Croatian
+// { code: 'id', name: 'Bahasa Indonesia' },// Indonesian
+   { code: 'it', name: 'Italiano' },        // Italian
+// { code: 'he', name: 'עברית' },           // Hebrew
+   { code: 'ka', name: 'ქართული' },         // Georgian
+// { code: 'lv', name: 'Latviešu' },        // Latvian
+// { code: 'lt', name: 'Lietuvių' },        // Lithuanian
+   { code: 'hu', name: 'Magyar' },          // Hungarian
+// { code: 'mk', name: 'Македонски' },      // Macedonian
+// { code: 'ms', name: 'Bahasa Melayu' },   // Malay
+   { code: 'nl', name: 'Nederlands' },      // Dutch
+   { code: 'ja', name: '日本語' },          // Japanese
+   { code: 'nb', name: 'Norsk' },           // Norwegian Bokmål
+// { code: 'nn', name: 'Norsk Nynorsk' },   // Norwegian Nynorsk
+// { code: 'pl', name: 'Polski' },          // Polish
+   { code: 'pt', name: 'Português' },       // Portuguese
+// { code: 'pt-BR', name: 'Português (Brazil)' }, // Portuguese (Brazil)
+// { code: 'ro', name: 'Română' },          // Romanian
+// { code: 'ru', name: 'Русский' },         // Russian
+// { code: 'sk', name: 'Slovenčina' },      // Slovak
+   { code: 'sl', name: 'Slovenščina' },     // Slovenian
+// { code: 'sr', name: 'Српски / srpski' }, // Serbian
+// { code: 'sh', name: 'Srpskohrvatski / српскохрватски' },// Serbo-Croatian
+   { code: 'fi', name: 'Suomi' },           // Finnish
+   { code: 'sv', name: 'Svenska' },         // Swedish
+// { code: 'th', name: 'ไทย' },             // Thai
+   { code: 'tr', name: 'Türkçe' },          // Turkish
+   { code: 'uk', name: 'Українська' },      // Ukrainian
+   { code: 'vi', name: 'Tiếng Việt' },      // Vietnamese
+   { code: 'zh', name: '中文' },            // Chinese
+];

frontend/src/app/app.module.ts

@@ -1,57 +1,129 @@
-import { BrowserModule } from '@angular/platform-browser';
+import { BrowserModule, BrowserTransferStateModule } from '@angular/platform-browser';
 import { NgModule } from '@angular/core';
+import { HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { InfiniteScrollModule } from 'ngx-infinite-scroll';
 
-import { AppComponent } from './app.component';
-import { BlockchainComponent } from './blockchain/blockchain.component';
 import { AppRoutingModule } from './app-routing.module';
+import { AppComponent } from './components/app/app.component';
+
+import { StartComponent } from './components/start/start.component';
+import { ElectrsApiService } from './services/electrs-api.service';
+import { TransactionComponent } from './components/transaction/transaction.component';
+import { TransactionsListComponent } from './components/transactions-list/transactions-list.component';
+import { AmountComponent } from './components/amount/amount.component';
+import { StateService } from './services/state.service';
+import { BlockComponent } from './components/block/block.component';
+import { AddressComponent } from './components/address/address.component';
+import { SearchFormComponent } from './components/search-form/search-form.component';
+import { LatestBlocksComponent } from './components/latest-blocks/latest-blocks.component';
+import { WebsocketService } from './services/websocket.service';
+import { AddressLabelsComponent } from './components/address-labels/address-labels.component';
+import { MempoolBlocksComponent } from './components/mempool-blocks/mempool-blocks.component';
+import { MasterPageComponent } from './components/master-page/master-page.component';
+import { AboutComponent } from './components/about/about.component';
+import { TelevisionComponent } from './components/television/television.component';
+import { StatisticsComponent } from './components/statistics/statistics.component';
+import { ChartistComponent } from './components/statistics/chartist.component';
+import { BlockchainBlocksComponent } from './components/blockchain-blocks/blockchain-blocks.component';
+import { BlockchainComponent } from './components/blockchain/blockchain.component';
+import { FooterComponent } from './components/footer/footer.component';
+import { AudioService } from './services/audio.service';
+import { MempoolBlockComponent } from './components/mempool-block/mempool-block.component';
+import { FeeDistributionGraphComponent } from './components/fee-distribution-graph/fee-distribution-graph.component';
+import { TimespanComponent } from './components/timespan/timespan.component';
+import { SeoService } from './services/seo.service';
+import { MempoolGraphComponent } from './components/mempool-graph/mempool-graph.component';
+import { AssetComponent } from './components/asset/asset.component';
+import { AssetsComponent } from './assets/assets.component';
+import { StatusViewComponent } from './components/status-view/status-view.component';
+import { MinerComponent } from './components/miner/miner.component';
 import { SharedModule } from './shared/shared.module';
-import { MemPoolService } from './services/mem-pool.service';
-import { HttpClientModule } from '@angular/common/http';
-import { FooterComponent } from './footer/footer.component';
-import { AboutComponent } from './about/about.component';
-import { TxBubbleComponent } from './tx-bubble/tx-bubble.component';
-import { ReactiveFormsModule } from '@angular/forms';
-import { BlockModalComponent } from './blockchain-blocks/block-modal/block-modal.component';
-import { StatisticsComponent } from './statistics/statistics.component';
-import { ProjectedBlockModalComponent } from './blockchain-projected-blocks/projected-block-modal/projected-block-modal.component';
-import { TelevisionComponent } from './television/television.component';
-import { BlockchainBlocksComponent } from './blockchain-blocks/blockchain-blocks.component';
-import { BlockchainProjectedBlocksComponent } from './blockchain-projected-blocks/blockchain-projected-blocks.component';
-import { ApiService } from './services/api.service';
-import { MasterPageComponent } from './master-page/master-page.component';
-import { FeeDistributionGraphComponent } from './fee-distribution-graph/fee-distribution-graph.component';
+import { NgbTypeaheadModule } from '@ng-bootstrap/ng-bootstrap';
+import { FeesBoxComponent } from './components/fees-box/fees-box.component';
+import { DashboardComponent } from './dashboard/dashboard.component';
+import { FontAwesomeModule, FaIconLibrary } from '@fortawesome/angular-fontawesome';
+import { faAngleDown, faAngleUp, faBolt, faChartArea, faCogs, faCubes, faDatabase, faExchangeAlt, faInfoCircle,
+  faLink, faList, faSearch, faTachometerAlt, faThList, faTint, faTv } from '@fortawesome/free-solid-svg-icons';
+import { ApiDocsComponent } from './components/api-docs/api-docs.component';
+import { TermsOfServiceComponent } from './components/terms-of-service/terms-of-service.component';
+import { StorageService } from './services/storage.service';
+import { HttpCacheInterceptor } from './services/http-cache.interceptor';
 
 @NgModule({
   declarations: [
     AppComponent,
-    BlockchainComponent,
-    FooterComponent,
-    StatisticsComponent,
     AboutComponent,
-    TxBubbleComponent,
-    BlockModalComponent,
-    ProjectedBlockModalComponent,
-    TelevisionComponent,
-    BlockchainBlocksComponent,
-    BlockchainProjectedBlocksComponent,
     MasterPageComponent,
+    TelevisionComponent,
+    BlockchainComponent,
+    StartComponent,
+    BlockchainBlocksComponent,
+    StatisticsComponent,
+    TransactionComponent,
+    BlockComponent,
+    TransactionsListComponent,
+    AddressComponent,
+    AmountComponent,
+    LatestBlocksComponent,
+    SearchFormComponent,
+    TimespanComponent,
+    AddressLabelsComponent,
+    MempoolBlocksComponent,
+    ChartistComponent,
+    FooterComponent,
+    MempoolBlockComponent,
     FeeDistributionGraphComponent,
+    MempoolGraphComponent,
+    AssetComponent,
+    AssetsComponent,
+    MinerComponent,
+    StatusViewComponent,
+    FeesBoxComponent,
+    DashboardComponent,
+    ApiDocsComponent,
+    TermsOfServiceComponent,
   ],
   imports: [
-    ReactiveFormsModule,
-    BrowserModule,
-    HttpClientModule,
+    BrowserModule.withServerTransition({ appId: 'serverApp' }),
+    BrowserTransferStateModule,
     AppRoutingModule,
+    HttpClientModule,
+    BrowserAnimationsModule,
+    InfiniteScrollModule,
+    NgbTypeaheadModule,
+    FontAwesomeModule,
     SharedModule,
   ],
   providers: [
-    ApiService,
-    MemPoolService,
-  ],
-  entryComponents: [
-    BlockModalComponent,
-    ProjectedBlockModalComponent,
+    ElectrsApiService,
+    StateService,
+    WebsocketService,
+    AudioService,
+    SeoService,
+    StorageService,
+    { provide: HTTP_INTERCEPTORS, useClass: HttpCacheInterceptor, multi: true }
   ],
   bootstrap: [AppComponent]
 })
-export class AppModule { }
+export class AppModule {
+  constructor(library: FaIconLibrary) {
+    library.addIcons(faInfoCircle);
+    library.addIcons(faChartArea);
+    library.addIcons(faTv);
+    library.addIcons(faTachometerAlt);
+    library.addIcons(faCubes);
+    library.addIcons(faCogs);
+    library.addIcons(faThList);
+    library.addIcons(faList);
+    library.addIcons(faTachometerAlt);
+    library.addIcons(faDatabase);
+    library.addIcons(faSearch);
+    library.addIcons(faLink);
+    library.addIcons(faBolt);
+    library.addIcons(faTint);
+    library.addIcons(faAngleDown);
+    library.addIcons(faAngleUp);
+    library.addIcons(faExchangeAlt);
+  }
+}

frontend/src/app/app.server.module.ts

@@ -0,0 +1,20 @@
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { NgModule } from '@angular/core';
+import { ServerModule, ServerTransferStateModule } from '@angular/platform-server';
+
+import { AppModule } from './app.module';
+import { AppComponent } from './components/app/app.component';
+import { HttpCacheInterceptor } from './services/http-cache.interceptor';
+
+@NgModule({
+  imports: [
+    AppModule,
+    ServerModule,
+    ServerTransferStateModule,
+  ],
+  providers: [
+    { provide: HTTP_INTERCEPTORS, useClass: HttpCacheInterceptor, multi: true }
+  ],
+  bootstrap: [AppComponent],
+})
+export class AppServerModule {}

frontend/src/app/assets/assets.component.html

@@ -0,0 +1,75 @@
+<div class="container-xl">
+  <h1 style="float: left;" i18n="Registered assets page header">Registered assets</h1>
+  <br>
+
+  <div class="clearfix"></div>
+
+  <form [formGroup]="searchForm" class="form-inline">
+    <div class="input-group m-2">
+      <input style="width: 250px;" formControlName="searchText" type="text" class="form-control" i18n-placeholder="Search Assets Placeholder Text" placeholder="Search asset">
+      <div class="input-group-append">
+        <button [disabled]="!searchForm.get('searchText')?.value.length" class="btn btn-secondary" type="button" (click)="searchForm.get('searchText')?.setValue('');" autocomplete="off" i18n="Search Clear Button">Clear</button>
+      </div>
+    </div>
+  </form>
+
+  <ng-container *ngIf="(assets$ | async) as filteredAssets; else isLoading">
+    <table class="table table-borderless table-striped">
+      <thead>
+        <th class="td-name" i18n="Asset name header">Name</th>
+        <th i18n="Asset ticker header">Ticker</th>
+        <th class="d-none d-md-block" i18n="Asset Issuer Domain header">Issuer domain</th>
+        <th i18n="Asset ID header">Asset ID</th>
+        <th class="d-none d-lg-block" i18n="Asset issuance transaction header">Issuance TX</th>
+      </thead>
+      <tbody>
+        <tr *ngFor="let asset of filteredAssets; trackBy: trackByAsset">
+          <td class="td-name">{{ asset.name }}</td>
+          <td>{{ asset.ticker }}</td>
+          <td class="d-none d-md-block"><a *ngIf="asset.entity" target="_blank" href="{{ 'http://' + asset.entity.domain }}">{{ asset.entity.domain }}</a></td>
+          <td><a [routerLink]="['/asset/' | relativeUrl, asset.asset_id]">{{ asset.asset_id | shortenString : 13 }}</a> <app-clipboard class="d-none d-sm-inline-block" [text]="asset.asset_id"></app-clipboard></td>
+          <td class="d-none d-lg-block"><ng-template [ngIf]="asset.issuance_txin"><a [routerLink]="['/tx/' | relativeUrl, asset.issuance_txin.txid]">{{ asset.issuance_txin.txid | shortenString : 13 }}</a> <app-clipboard class="d-none d-sm-inline-block" [text]="asset.issuance_txin.txid"></app-clipboard></ng-template></td>
+        </tr> 
+      </tbody>
+    </table>
+
+    <br>
+
+    <ngb-pagination [collectionSize]="assets.length" [rotate]="true" [pageSize]="itemsPerPage" [(page)]="page" (pageChange)="pageChange(page)" [maxSize]="5" [boundaryLinks]="true"></ngb-pagination>
+
+  </ng-container>
+
+  <ng-template #isLoading>
+
+    <table class="table table-borderless table-striped">
+      <thead>
+        <th i18n="Asset name header">Name</th>
+        <th i18n="Asset ticker header">Ticker</th>
+        <th i18n="Asset Issuer Domain header">Issuer domain</th>
+        <th i18n="Asset ID header">Asset ID</th>
+        <th i18n="Asset issuance transaction header">Issuance TX</th>
+      </thead>
+      <tbody>
+        <tr *ngFor="let dummy of [0,0,0]">
+          <td><span class="skeleton-loader"></span></td>
+          <td><span class="skeleton-loader"></span></td>
+          <td class="d-none d-md-block"><span class="skeleton-loader"></span></td>
+          <td><span class="skeleton-loader"></span></td>
+          <td class="d-none d-lg-block"><span class="skeleton-loader"></span></td>
+        </tr> 
+      </tbody>
+    </table>
+
+  </ng-template>
+
+  <ng-template [ngIf]="error">
+    <div class="text-center">
+      <ng-container i18n="Asset data load error">Error loading assets data.</ng-container>
+      <br>
+      <i>{{ error.error }}</i>
+    </div>
+  </ng-template>
+
+</div>
+
+<br>

frontend/src/app/assets/assets.component.scss

@@ -0,0 +1,6 @@
+.td-name {
+  max-width: 200px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}

frontend/src/app/assets/assets.component.spec.ts

@@ -0,0 +1,25 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { AssetsComponent } from './assets.component';
+
+describe('AssetsComponent', () => {
+  let component: AssetsComponent;
+  let fixture: ComponentFixture<AssetsComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ AssetsComponent ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(AssetsComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

frontend/src/app/assets/assets.component.ts

@@ -0,0 +1,155 @@
+import { Component, OnInit, ChangeDetectionStrategy } from '@angular/core';
+import { AssetsService } from '../services/assets.service';
+import { environment } from 'src/environments/environment';
+import { FormGroup, FormBuilder, Validators } from '@angular/forms';
+import { distinctUntilChanged, map, filter, mergeMap, tap, take } from 'rxjs/operators';
+import { ActivatedRoute, Router } from '@angular/router';
+import { merge, combineLatest, Observable } from 'rxjs';
+import { AssetExtended } from '../interfaces/electrs.interface';
+import { SeoService } from '../services/seo.service';
+
+@Component({
+  selector: 'app-assets',
+  templateUrl: './assets.component.html',
+  styleUrls: ['./assets.component.scss'],
+  changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class AssetsComponent implements OnInit {
+  nativeAssetId = environment.nativeAssetId;
+  assets: AssetExtended[];
+  assetsCache: AssetExtended[];
+  searchForm: FormGroup;
+  assets$: Observable<AssetExtended[]>;
+
+  error: any;
+
+  page = 1;
+  itemsPerPage: number;
+  contentSpace = window.innerHeight - (250 + 200);
+  fiveItemsPxSize = 250;
+
+  constructor(
+    private assetsService: AssetsService,
+    private formBuilder: FormBuilder,
+    private route: ActivatedRoute,
+    private router: Router,
+    private seoService: SeoService,
+  ) { }
+
+  ngOnInit() {
+    this.seoService.setTitle($localize`:@@ee8f8008bae6ce3a49840c4e1d39b4af23d4c263:Assets`);
+    this.itemsPerPage = Math.max(Math.round(this.contentSpace / this.fiveItemsPxSize) * 5, 10);
+
+    this.searchForm = this.formBuilder.group({
+      searchText: [{ value: '', disabled: true }, Validators.required]
+    });
+
+    this.assets$ = combineLatest([
+      this.assetsService.getAssetsJson$,
+      this.route.queryParams
+    ])
+    .pipe(
+      take(1),
+      mergeMap(([assets, qp]) => {
+        this.assets = Object.values(assets);
+        // @ts-ignore
+        this.assets.push({
+          name: 'Liquid Bitcoin',
+          ticker: 'L-BTC',
+          asset_id: this.nativeAssetId,
+        });
+        this.assets = this.assets.sort((a: any, b: any) => a.name.localeCompare(b.name));
+        this.assetsCache = this.assets;
+        this.searchForm.get('searchText').enable();
+
+        if (qp.search) {
+          this.searchForm.get('searchText').setValue(qp.search, { emitEvent: false });
+        }
+
+        return merge(
+          this.searchForm.get('searchText').valueChanges
+            .pipe(
+              distinctUntilChanged(),
+              tap((text) => {
+                this.page = 1;
+                this.searchTextChanged(text);
+              })
+            ),
+          this.route.queryParams
+            .pipe(
+              filter((queryParams) => {
+                const newPage = parseInt(queryParams.page, 10);
+                if (newPage !== this.page || queryParams.search !== this.searchForm.get('searchText').value) {
+                  return true;
+                }
+                return false;
+              }),
+              map((queryParams) => {
+                if (queryParams.page) {
+                  const newPage = parseInt(queryParams.page, 10);
+                  this.page = newPage;
+                } else {
+                  this.page = 1;
+                }
+                if (this.searchForm.get('searchText').value !== (queryParams.search || '')) {
+                  this.searchTextChanged(queryParams.search);
+                }
+                if (queryParams.search) {
+                  this.searchForm.get('searchText').setValue(queryParams.search, { emitEvent: false });
+                  return queryParams.search;
+                }
+                return '';
+              })
+            ),
+        );
+      }),
+      map((searchText) => {
+        const start = (this.page - 1) * this.itemsPerPage;
+        if (searchText.length ) {
+          const filteredAssets = this.assetsCache.filter((asset) => asset.name.toLowerCase().indexOf(searchText.toLowerCase()) > -1
+            || asset.ticker.toLowerCase().indexOf(searchText.toLowerCase()) > -1);
+          this.assets = filteredAssets;
+          return filteredAssets.slice(start, this.itemsPerPage + start);
+        } else {
+          this.assets = this.assetsCache;
+          return this.assets.slice(start, this.itemsPerPage + start);
+        }
+      })
+    );
+  }
+
+  pageChange(page: number) {
+    const queryParams = { page: page, search: this.searchForm.get('searchText').value };
+    if (queryParams.search === '') {
+      queryParams.search = null;
+    }
+    if (queryParams.page === 1) {
+      queryParams.page = null;
+    }
+    this.page = -1;
+    this.router.navigate([], {
+      relativeTo: this.route,
+      queryParams: queryParams,
+      queryParamsHandling: 'merge',
+    });
+  }
+
+  searchTextChanged(text: string) {
+    const queryParams = { search: text, page: 1 };
+    if (queryParams.search === '') {
+      queryParams.search = null;
+    }
+    if (queryParams.page === 1) {
+      queryParams.page = null;
+    }
+    this.router.navigate([], {
+      relativeTo: this.route,
+      queryParams: queryParams,
+      queryParamsHandling: 'merge',
+    });
+  }
+
+  trackByAsset(index: number, asset: any) {
+    return asset.asset_id;
+  }
+}

frontend/src/app/bisq/bisq-address/bisq-address.component.html

@@ -0,0 +1,110 @@
+<div class="container-xl">
+  <h1 style="float: left;" i18n="shared.address">Address</h1>
+  <a [routerLink]="['/address/' | relativeUrl, addressString]" style="line-height: 56px; margin-left: 10px;">
+    <span class="d-inline d-lg-none">{{ addressString | shortenString : 24 }}</span>
+    <span class="d-none d-lg-inline">{{ addressString }}</span>
+  </a>
+  <app-clipboard [text]="addressString"></app-clipboard>
+  <br>
+
+  <div class="clearfix"></div>
+
+  <ng-template [ngIf]="!isLoadingAddress && !error">
+    <div class="box">
+
+      <div class="row">
+        <div class="col">
+          <table class="table table-borderless table-striped">
+            <tbody>
+              <tr>
+                <td i18n="address.total-received">Total received</td>
+                <td>{{ totalReceived / 100 | number: '1.2-2' }} BSQ</td>
+              </tr>
+              <tr>
+                <td i18n="address.total-sent">Total sent</td>
+                <td>{{ totalSent / 100 | number: '1.2-2' }} BSQ</td>
+              </tr>
+              <tr>
+                <td i18n="address.balance">Balance</td>
+                <td>{{ (totalReceived - totalSent) / 100 | number: '1.2-2' }} BSQ (<app-bsq-amount [bsq]="totalReceived - totalSent" [forceFiat]="true" [green]="true"></app-bsq-amount>)</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+        <div class="w-100 d-block d-md-none"></div>
+        <div class="col qrcode-col">
+          <div class="qr-wrapper">
+            <app-qrcode [data]="addressString"></app-qrcode>
+          </div>
+        </div>
+      </div>
+
+    </div>
+
+    <br>
+
+    <h2>
+      <ng-container *ngTemplateOutlet="transactions.length === 1 ? transactionsSingular : transactionsPlural; context: {$implicit: transactions.length}"></ng-container>
+      <ng-template #transactionsSingular let-i i18n="shared.transaction-count.singular">{{ i }} transaction</ng-template>
+      <ng-template #transactionsPlural let-i i18n="shared.transaction-count.plural">{{ i }} transactions</ng-template>
+    </h2>
+
+    <ng-template ngFor let-tx [ngForOf]="transactions">
+
+      <div class="header-bg box" style="padding: 10px; margin-bottom: 10px;">
+        <a [routerLink]="['/tx/' | relativeUrl, tx.id]" [state]="{ data: tx }">
+          <span style="float: left;" class="d-block d-md-none">{{ tx.id | shortenString : 16 }}</span>
+          <span style="float: left;" class="d-none d-md-block">{{ tx.id }}</span>
+        </a>
+        <div class="float-right">
+          {{ tx.time | date:'yyyy-MM-dd HH:mm' }}
+        </div>
+        <div class="clearfix"></div>
+      </div>
+  
+      <app-bisq-transfers [tx]="tx" [showConfirmations]="true"></app-bisq-transfers>
+  
+      <br>
+    </ng-template>
+
+  </ng-template>
+
+  <ng-template [ngIf]="isLoadingAddress && !error">
+
+    <div class="box">
+      <div class="row">
+        <div class="col">
+          <table class="table table-borderless table-striped">
+            <tbody>
+              <tr>
+                <td colspan="2"><span class="skeleton-loader"></span></td>
+              </tr>
+              <tr>
+                <td colspan="2"><span class="skeleton-loader"></span></td>
+              </tr>
+              <tr>
+                <td colspan="2"><span class="skeleton-loader"></span></td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+        <div class="w-100 d-block d-md-none"></div>
+        <div class="col">
+          
+        </div>
+      </div>
+    </div>
+
+  </ng-template>
+
+  <ng-template [ngIf]="error">
+    <div class="text-center">
+      Error loading address data.
+      <br>
+      <i>{{ error.error }}</i>
+    </div>
+  </ng-template>
+
+</div>
+
+<br>

frontend/src/app/bisq/bisq-address/bisq-address.component.scss

@@ -0,0 +1,23 @@
+.qr-wrapper {
+  background-color: #FFF;
+  padding: 10px;
+  padding-bottom: 5px;
+  display: inline-block;
+  margin-right: 25px;
+}
+
+@media (min-width: 576px) {
+  .qrcode-col {
+    text-align: right;
+  }
+}
+@media (max-width: 575.98px) {
+  .qrcode-col {
+    text-align: center;
+  }
+
+  .qrcode-col > div {
+    margin-top: 20px;
+    margin-right: 0px;
+  }
+}

frontend/src/app/bisq/bisq-address/bisq-address.component.ts

@@ -0,0 +1,82 @@
+import { Component, OnInit, OnDestroy } from '@angular/core';
+import { SeoService } from 'src/app/services/seo.service';
+import { switchMap, filter, catchError } from 'rxjs/operators';
+import { ParamMap, ActivatedRoute } from '@angular/router';
+import { Subscription, of } from 'rxjs';
+import { BisqTransaction } from '../bisq.interfaces';
+import { BisqApiService } from '../bisq-api.service';
+
+@Component({
+  selector: 'app-bisq-address',
+  templateUrl: './bisq-address.component.html',
+  styleUrls: ['./bisq-address.component.scss']
+})
+export class BisqAddressComponent implements OnInit, OnDestroy {
+  transactions: BisqTransaction[];
+  addressString: string;
+  isLoadingAddress = true;
+  error: any;
+  mainSubscription: Subscription;
+
+  totalReceived = 0;
+  totalSent = 0;
+
+  constructor(
+    private route: ActivatedRoute,
+    private seoService: SeoService,
+    private bisqApiService: BisqApiService,
+  ) { }
+
+  ngOnInit() {
+    this.mainSubscription = this.route.paramMap
+      .pipe(
+        switchMap((params: ParamMap) => {
+          this.error = undefined;
+          this.isLoadingAddress = true;
+          this.transactions = null;
+          document.body.scrollTo(0, 0);
+          this.addressString = params.get('id') || '';
+          this.seoService.setTitle($localize`:@@bisq-address.component.browser-title:Address: ${this.addressString}:INTERPOLATION:`);
+
+          return this.bisqApiService.getAddress$(this.addressString)
+            .pipe(
+              catchError((err) => {
+                this.isLoadingAddress = false;
+                this.error = err;
+                console.log(err);
+                return of(null);
+              })
+            );
+          }),
+        filter((transactions) => transactions !== null)
+      )
+      .subscribe((transactions: BisqTransaction[]) => {
+        this.transactions = transactions;
+        this.updateChainStats();
+        this.isLoadingAddress = false;
+      },
+      (error) => {
+        console.log(error);
+        this.error = error;
+        this.isLoadingAddress = false;
+      });
+  }
+
+  updateChainStats() {
+    const shortenedAddress = this.addressString.substr(1);
+
+    this.totalSent = this.transactions.reduce((acc, tx) =>
+      acc + tx.inputs
+        .filter((input) => input.address === shortenedAddress)
+        .reduce((a, input) => a + input.bsqAmount, 0), 0);
+
+    this.totalReceived = this.transactions.reduce((acc, tx) =>
+      acc + tx.outputs
+        .filter((output) => output.address === shortenedAddress)
+        .reduce((a, output) => a + output.bsqAmount, 0), 0);
+  }
+
+  ngOnDestroy() {
+    this.mainSubscription.unsubscribe();
+  }
+}

frontend/src/app/bisq/bisq-api.service.ts

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpResponse, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { BisqTransaction, BisqBlock, BisqStats } from './bisq.interfaces';
+
+const API_BASE_URL = '/bisq/api';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BisqApiService {
+  apiBaseUrl: string;
+
+  constructor(
+    private httpClient: HttpClient,
+  ) { }
+
+  getStats$(): Observable<BisqStats> {
+    return this.httpClient.get<BisqStats>(API_BASE_URL + '/stats');
+  }
+
+  getTransaction$(txId: string): Observable<BisqTransaction> {
+    return this.httpClient.get<BisqTransaction>(API_BASE_URL + '/tx/' + txId);
+  }
+
+  listTransactions$(start: number, length: number, types: string[]): Observable<HttpResponse<BisqTransaction[]>> {
+    let params = new HttpParams();
+    types.forEach((t: string) => {
+      params = params.append('types[]', t);
+    });
+    return this.httpClient.get<BisqTransaction[]>(API_BASE_URL + `/txs/${start}/${length}`, { params, observe: 'response' });
+  }
+
+  getBlock$(hash: string): Observable<BisqBlock> {
+    return this.httpClient.get<BisqBlock>(API_BASE_URL + '/block/' + hash);
+  }
+
+  listBlocks$(start: number, length: number): Observable<HttpResponse<BisqBlock[]>> {
+    return this.httpClient.get<BisqBlock[]>(API_BASE_URL + `/blocks/${start}/${length}`, { observe: 'response' });
+  }
+
+  getAddress$(address: string): Observable<BisqTransaction[]> {
+    return this.httpClient.get<BisqTransaction[]>(API_BASE_URL + '/address/' + address);
+  }
+}

frontend/src/app/bisq/bisq-block/bisq-block.component.html

@@ -0,0 +1,112 @@
+<div class="container-xl">
+
+  <div class="title-block">
+    <h1><ng-template [ngIf]="blockHeight" i18n="block.block">Block <a [routerLink]="['/block/' | relativeUrl, blockHash]">{{ blockHeight }}</a></ng-template></h1>
+  </div>
+
+  <div class="clearfix"></div>
+
+  <ng-template [ngIf]="!isLoading && !error">
+
+    <div class="box">
+      <div class="row">
+        <div class="col-sm">
+          <table class="table table-borderless table-striped">
+            <tbody>
+              <tr>
+                <td class="td-width" i18n="block.hash">Hash</td>
+                <td><a [routerLink]="['/block/' | relativeUrl, block.hash]" title="{{ block.hash }}">{{ block.hash | shortenString : 13 }}</a> <app-clipboard class="d-none d-sm-inline-block" [text]="block.hash"></app-clipboard></td>
+              </tr>
+              <tr>
+                <td i18n="transaction.timestamp|Transaction Timestamp">Timestamp</td>
+                <td>
+                  {{ block.time | date:'yyyy-MM-dd HH:mm' }}
+                  <div class="lg-inline">
+                    <i>(<app-time-since [time]="block.time / 1000" [fastRender]="true"></app-time-since>)</i>
+                  </div>
+                </td>
+              </tr>
+          </table>
+        </div>
+        <div class="col-sm">
+          <table class="table table-borderless table-striped">
+            <tbody>
+              <tr>
+                <td class="td-width" i18n="block.previous_hash|Transaction Previous Hash">Previous hash</td>
+                <td><a [routerLink]="['/block/' | relativeUrl, block.previousBlockHash]" title="{{ block.hash }}">{{ block.previousBlockHash | shortenString : 13 }}</a> <app-clipboard class="d-none d-sm-inline-block" [text]="block.previousBlockHash"></app-clipboard></td>
+              </tr>
+          </table>
+        </div>
+      </div>
+    </div>
+
+    <div class="clearfix"></div>
+
+    <br>
+
+    <h2>
+      <ng-container *ngTemplateOutlet="block.txs.length === 1 ? transactionsSingular : transactionsPlural; context: {$implicit: block.txs.length| number}"></ng-container>
+      <ng-template #transactionsSingular let-i i18n="shared.transaction-count.singular">{{ i }} transaction</ng-template>
+      <ng-template #transactionsPlural let-i i18n="shared.transaction-count.plural">{{ i }} transactions</ng-template>
+    </h2>
+
+    <ng-template ngFor let-tx [ngForOf]="block.txs">
+
+      <div class="header-bg box" style="padding: 10px; margin-bottom: 10px;">
+        <a [routerLink]="['/tx/' | relativeUrl, tx.id]" [state]="{ data: tx }">
+          <span style="float: left;" class="d-block d-md-none">{{ tx.id | shortenString : 16 }}</span>
+          <span style="float: left;" class="d-none d-md-block">{{ tx.id }}</span>
+        </a>
+        <div class="float-right">
+          {{ tx.time | date:'yyyy-MM-dd HH:mm' }}
+        </div>
+        <div class="clearfix"></div>
+      </div>
+  
+      <app-bisq-transfers [tx]="tx" [showConfirmations]="true"></app-bisq-transfers>
+  
+      <br>
+    </ng-template>
+
+  </ng-template>
+
+  <ng-template [ngIf]="isLoading && !error">
+    <div class="box">
+      <div class="row">
+        <div class="col-sm">
+          <table class="table table-borderless table-striped">
+            <tbody>
+              <tr>
+                <td class="td-width" i18n="block.hash">Hash</td>
+                <td><span class="skeleton-loader"></span></td>
+              </tr>
+              <tr>
+                <td i18n="transaction.timestamp|Transaction Timestamp">Timestamp</td>
+                <td><span class="skeleton-loader"></span></td>
+              </tr>
+          </table>
+        </div>
+        <div class="col-sm">
+          <table class="table table-borderless table-striped">
+            <tbody>
+              <tr>
+                <td class="td-width" i18n="block.previous_hash|Transaction Previous Hash">Previous hash</td>
+                <td><span class="skeleton-loader"></span></td>
+              </tr>
+          </table>
+        </div>
+      </div>
+    </div>
+  </ng-template>
+
+  <ng-template [ngIf]="error">
+    <div class="clearfix"></div>
+
+    <div class="text-center">
+      Error loading block
+      <br>
+      <i>{{ error.status }}: {{ error.statusText }}</i>
+    </div>
+  </ng-template>
+
+</div>

frontend/src/app/bisq/bisq-block/bisq-block.component.scss

@@ -0,0 +1,10 @@
+
+.td-width {
+  width: 175px;
+}
+
+@media (max-width: 767.98px) {
+	.td-width {
+		width: 140px;
+	}
+}

frontend/src/app/bisq/bisq-block/bisq-block.component.ts

@@ -0,0 +1,98 @@
+import { Component, OnInit, OnDestroy } from '@angular/core';
+import { BisqBlock } from 'src/app/bisq/bisq.interfaces';
+import { Location } from '@angular/common';
+import { BisqApiService } from '../bisq-api.service';
+import { ActivatedRoute, ParamMap, Router } from '@angular/router';
+import { Subscription, of } from 'rxjs';
+import { switchMap, catchError } from 'rxjs/operators';
+import { SeoService } from 'src/app/services/seo.service';
+import { ElectrsApiService } from 'src/app/services/electrs-api.service';
+import { HttpErrorResponse } from '@angular/common/http';
+
+@Component({
+  selector: 'app-bisq-block',
+  templateUrl: './bisq-block.component.html',
+  styleUrls: ['./bisq-block.component.scss']
+})
+export class BisqBlockComponent implements OnInit, OnDestroy {
+  block: BisqBlock;
+  subscription: Subscription;
+  blockHash = '';
+  blockHeight = 0;
+  isLoading = true;
+  error: HttpErrorResponse | null;
+
+  constructor(
+    private bisqApiService: BisqApiService,
+    private route: ActivatedRoute,
+    private seoService: SeoService,
+    private electrsApiService: ElectrsApiService,
+    private router: Router,
+    private location: Location,
+  ) { }
+
+  ngOnInit(): void {
+    this.subscription = this.route.paramMap
+      .pipe(
+        switchMap((params: ParamMap) => {
+          const blockHash = params.get('id') || '';
+          document.body.scrollTo(0, 0);
+          this.isLoading = true;
+          this.error = null;
+          if (history.state.data && history.state.data.blockHeight) {
+            this.blockHeight = history.state.data.blockHeight;
+          }
+          if (history.state.data && history.state.data.block) {
+            this.blockHeight = history.state.data.block.height;
+            return of(history.state.data.block);
+          }
+
+          let isBlockHeight = false;
+          if (/^[0-9]+$/.test(blockHash)) {
+            isBlockHeight = true;
+          } else {
+            this.blockHash = blockHash;
+          }
+
+          if (isBlockHeight) {
+            return this.electrsApiService.getBlockHashFromHeight$(parseInt(blockHash, 10))
+              .pipe(
+                switchMap((hash) => {
+                  if (!hash) {
+                    return;
+                  }
+                  this.blockHash = hash;
+                  this.location.replaceState(
+                    this.router.createUrlTree(['/bisq/block/', hash]).toString()
+                  );
+                  return this.bisqApiService.getBlock$(this.blockHash)
+                    .pipe(catchError(this.caughtHttpError.bind(this)));
+                }),
+                catchError(this.caughtHttpError.bind(this))
+              );
+          }
+
+          return this.bisqApiService.getBlock$(this.blockHash)
+            .pipe(catchError(this.caughtHttpError.bind(this)));
+        })
+      )
+      .subscribe((block: BisqBlock) => {
+        if (!block) {
+          return;
+        }
+        this.isLoading = false;
+        this.blockHeight = block.height;
+        this.seoService.setTitle($localize`:@@bisq-block.component.browser-title:Block ${block.height}:BLOCK_HEIGHT:: ${block.hash}:BLOCK_HASH:`);
+        this.block = block;
+      });
+  }
+
+  ngOnDestroy() {
+    this.subscription.unsubscribe();
+  }
+
+  caughtHttpError(err: HttpErrorResponse){
+    this.error = err;
+    return of(null);
+  }
+}