machankura/mempool
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use 'request' instead of 'axios' for electrs api requests.

Browse Source
This commit is contained in:
Simon Lindh 2019-12-06 21:59:43 +01:00
parent 12139fac3a
commit aa8bccdb8f
2 changed files with 99 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
backend/package.json
View File

@ -13,7 +13,6 @@
}, },
"license": "MIT", "license": "MIT",
"dependencies": { "dependencies": {
"axios": "^0.19.0",
"bitcoin": "^3.0.1", "bitcoin": "^3.0.1",
"compression": "^1.7.3", "compression": "^1.7.3",
"express": "^4.16.3", "express": "^4.16.3",

201
backend/src/api/bitcoin/esplora-api.ts
View File

@ -1,185 +1,182 @@
const config = require('../../../mempool-config.json'); const config = require('../../../mempool-config.json');
import { ITransaction, IMempoolInfo, IBlock } from '../../interfaces'; import { ITransaction, IMempoolInfo, IBlock } from '../../interfaces';
import { AbstractBitcoinApi } from './bitcoin-api-abstract-factory'; import { AbstractBitcoinApi } from './bitcoin-api-abstract-factory';
import axios, { AxiosResponse } from 'axios'; import * as request from 'request';
class EsploraApi implements AbstractBitcoinApi { class EsploraApi implements AbstractBitcoinApi {
client: any;
constructor() { constructor() {
this.client = axios.create({
baseURL: config.ESPLORA_API_URL,
timeout: 15000,
});
} }
getMempoolInfo(): Promise<IMempoolInfo> { getMempoolInfo(): Promise<IMempoolInfo> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/mempool', { json: true }, (err, res, response) => {
const response: AxiosResponse = await this.client.get('/mempool'); if (err) {
reject(err);
}
resolve({ resolve({
size: response.data.count, size: response.count,
bytes: response.data.vsize, bytes: response.vsize,
}); });
} catch (error) { });
reject(error);
}
}); });
} }
getRawMempool(): Promise<ITransaction['txid'][]> { getRawMempool(): Promise<ITransaction['txid'][]> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/mempool/txids', { json: true }, (err, res, response) => {
const response: AxiosResponse = await this.client.get('/mempool/txids'); if (err) {
resolve(response.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
getRawTransaction(txId: string): Promise<ITransaction> { getRawTransaction(txId: string): Promise<ITransaction> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/tx/' + txId, { json: true }, (err, res, response) => {
const response: AxiosResponse = await this.client.get('/tx/' + txId); if (err) {
reject(err);
}
response.vsize = Math.round(response.weight / 4);
response.fee = response.fee / 100000000;
response.blockhash = response.status.block_hash;
response.data.vsize = Math.round(response.data.weight / 4); resolve(response);
response.data.fee = response.data.fee / 100000000; });
response.data.blockhash = response.data.status.block_hash;
resolve(response.data);
} catch (error) {
reject(error);
}
}); });
} }
getBlockCount(): Promise<number> { getBlockCount(): Promise<number> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/blocks/tip/height', { json: true }, (err, res, response) => {
const response: AxiosResponse = await this.client.get('/blocks/tip/height'); if (err) {
resolve(response.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
getBlockAndTransactions(hash: string): Promise<IBlock> { getBlockAndTransactions(hash: string): Promise<IBlock> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/block/' + hash, { json: true }, (err, res, response) => {
const blockInfo: AxiosResponse = await this.client.get('/block/' + hash); if (err) {
const blockTxs: AxiosResponse = await this.client.get('/block/' + hash + '/txids'); reject(err);
}
request(config.ESPLORA_API_URL + '/block/' + hash + '/txids', { json: true }, (err2, res2, response2) => {
if (err2) {
reject(err2);
}
const block = response;
block.hash = hash;
block.nTx = block.tx_count;
block.time = block.timestamp;
block.tx = response2;
const block = blockInfo.data; resolve(block);
block.hash = hash; });
block.nTx = block.tx_count; });
block.time = block.timestamp;
block.tx = blockTxs.data;
resolve(block);
} catch (error) {
reject(error);
}
}); });
} }
getBlockHash(height: number): Promise<string> { getBlockHash(height: number): Promise<string> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/block-height/' + height, { json: true }, (err, res, response) => {
const response: AxiosResponse = await this.client.get('/block-height/' + height); if (err) {
resolve(response.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
getBlocks(): Promise<string> { getBlocks(): Promise<string> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/blocks', { json: true }, (err, res, response) => {
const response: AxiosResponse = await this.client.get('/blocks'); if (err) {
resolve(response.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
getBlocksFromHeight(height: number): Promise<string> { getBlocksFromHeight(height: number): Promise<string> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/blocks/' + height, { json: true }, (err, res, response) => {
const response: AxiosResponse = await this.client.get('/blocks/' + height); if (err) {
resolve(response.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
getBlock(hash: string): Promise<IBlock> { getBlock(hash: string): Promise<IBlock> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/block/' + hash, { json: true }, (err, res, response) => {
const blockInfo: AxiosResponse = await this.client.get('/block/' + hash); if (err) {
resolve(blockInfo.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
getBlockTransactions(hash: string): Promise<IBlock> { getBlockTransactions(hash: string): Promise<IBlock> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/block/' + hash + '/txs', { json: true }, (err, res, response) => {
const blockInfo: AxiosResponse = await this.client.get('/block/' + hash + '/txs'); if (err) {
resolve(blockInfo.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
getBlockTransactionsFromIndex(hash: string, index: number): Promise<IBlock> { getBlockTransactionsFromIndex(hash: string, index: number): Promise<IBlock> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/block/' + hash + '/txs/' + index, { json: true }, (err, res, response) => {
const blockInfo: AxiosResponse = await this.client.get('/block/' + hash + '/txs/' + index); if (err) {
resolve(blockInfo.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
getAddress(address: string): Promise<IBlock> { getAddress(address: string): Promise<IBlock> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/address/' + address, { json: true }, (err, res, response) => {
const blockInfo: AxiosResponse = await this.client.get('/address/' + address); if (err) {
resolve(blockInfo.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
getAddressTransactions(address: string): Promise<IBlock> { getAddressTransactions(address: string): Promise<IBlock> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/address/' + address + '/txs', { json: true }, (err, res, response) => {
const blockInfo: AxiosResponse = await this.client.get('/address/' + address + '/txs'); if (err) {
resolve(blockInfo.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
getAddressTransactionsFromLastSeenTxid(address: string, lastSeenTxid: string): Promise<IBlock> { getAddressTransactionsFromLastSeenTxid(address: string, lastSeenTxid: string): Promise<IBlock> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
try { request(config.ESPLORA_API_URL + '/address/' + address + '/txs/chain/' + lastSeenTxid, { json: true }, (err, res, response) => {
const blockInfo: AxiosResponse = await this.client.get('/address/' + address + '/txs/chain/' + lastSeenTxid); if (err) {
resolve(blockInfo.data); reject(err);
} catch (error) { }
reject(error); resolve(response);
} });
}); });
} }
} }