699 lines
17 KiB
JavaScript
699 lines
17 KiB
JavaScript
/*!
|
|
* fullnode.js - full node for hsd
|
|
* Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
|
|
* https://github.com/handshake-org/hsd
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
const assert = require('bsert');
|
|
const Chain = require('../blockchain/chain');
|
|
const Fees = require('../mempool/fees');
|
|
const Mempool = require('../mempool/mempool');
|
|
const Pool = require('../net/pool');
|
|
const Miner = require('../mining/miner');
|
|
const Node = require('./node');
|
|
const HTTP = require('./http');
|
|
const RPC = require('./rpc');
|
|
const blockstore = require('../blockstore');
|
|
const pkg = require('../pkg');
|
|
const {RootServer, RecursiveServer} = require('../dns/server');
|
|
|
|
/**
|
|
* Full Node
|
|
* Respresents a fullnode complete with a
|
|
* chain, mempool, miner, etc.
|
|
* @alias module:node.FullNode
|
|
* @extends Node
|
|
*/
|
|
|
|
class FullNode extends Node {
|
|
/**
|
|
* Create a full node.
|
|
* @constructor
|
|
* @param {Object?} options
|
|
*/
|
|
|
|
constructor(options) {
|
|
super(pkg.core, pkg.cfg, 'debug.log', options);
|
|
|
|
this.opened = false;
|
|
|
|
// SPV flag.
|
|
this.spv = false;
|
|
|
|
// Instantiate block storage.
|
|
this.blocks = blockstore.create({
|
|
network: this.network,
|
|
logger: this.logger,
|
|
prefix: this.config.prefix,
|
|
cacheSize: this.config.mb('block-cache-size'),
|
|
memory: this.memory
|
|
});
|
|
|
|
// Instantiate blockchain.
|
|
this.chain = new Chain({
|
|
network: this.network,
|
|
logger: this.logger,
|
|
blocks: this.blocks,
|
|
workers: this.workers,
|
|
memory: this.config.bool('memory'),
|
|
prefix: this.config.prefix,
|
|
maxFiles: this.config.uint('max-files'),
|
|
cacheSize: this.config.mb('cache-size'),
|
|
prune: this.config.bool('prune'),
|
|
checkpoints: this.config.bool('checkpoints'),
|
|
entryCache: this.config.uint('entry-cache'),
|
|
chainMigrate: this.config.uint('chain-migrate'),
|
|
indexTX: this.config.bool('index-tx'),
|
|
indexAddress: this.config.bool('index-address'),
|
|
compactTreeOnInit: this.config.bool('compact-tree-on-init'),
|
|
compactTreeInitInterval: this.config.uint('compact-tree-init-interval')
|
|
});
|
|
|
|
// Fee estimation.
|
|
this.fees = new Fees(this.logger);
|
|
this.fees.init();
|
|
|
|
// Mempool needs access to the chain.
|
|
this.mempool = new Mempool({
|
|
network: this.network,
|
|
logger: this.logger,
|
|
workers: this.workers,
|
|
chain: this.chain,
|
|
fees: this.fees,
|
|
memory: this.config.bool('memory'),
|
|
prefix: this.config.prefix,
|
|
persistent: this.config.bool('persistent-mempool'),
|
|
maxSize: this.config.mb('mempool-size'),
|
|
limitFree: this.config.bool('limit-free'),
|
|
limitFreeRelay: this.config.uint('limit-free-relay'),
|
|
requireStandard: this.config.bool('require-standard'),
|
|
rejectAbsurdFees: this.config.bool('reject-absurd-fees'),
|
|
indexAddress: this.config.bool('index-address'),
|
|
expiryTime: this.config.uint('mempool-expiry-time')
|
|
});
|
|
|
|
// Pool needs access to the chain and mempool.
|
|
this.pool = new Pool({
|
|
network: this.network,
|
|
logger: this.logger,
|
|
chain: this.chain,
|
|
mempool: this.mempool,
|
|
prefix: this.config.prefix,
|
|
compact: this.config.bool('compact'),
|
|
bip37: this.config.bool('bip37'),
|
|
identityKey: this.identityKey,
|
|
maxOutbound: this.config.uint('max-outbound'),
|
|
maxInbound: this.config.uint('max-inbound'),
|
|
maxProofRPS: this.config.uint('max-proof-rps'),
|
|
createSocket: this.config.func('create-socket'),
|
|
proxy: this.config.str('proxy'),
|
|
onion: this.config.bool('onion'),
|
|
brontideOnly: this.config.bool('brontide-only'),
|
|
upnp: this.config.bool('upnp'),
|
|
seeds: this.config.array('seeds'),
|
|
nodes: this.config.array('nodes'),
|
|
only: this.config.array('only'),
|
|
publicHost: this.config.str('public-host'),
|
|
publicPort: this.config.uint('public-port'),
|
|
publicBrontidePort: this.config.uint('public-brontide-port'),
|
|
host: this.config.str('host'),
|
|
port: this.config.uint('port'),
|
|
brontidePort: this.config.uint('brontide-port'),
|
|
listen: this.config.bool('listen'),
|
|
memory: this.config.bool('memory'),
|
|
agent: this.config.str('agent')
|
|
});
|
|
|
|
// Miner needs access to the chain and mempool.
|
|
this.miner = new Miner({
|
|
network: this.network,
|
|
logger: this.logger,
|
|
workers: this.workers,
|
|
chain: this.chain,
|
|
mempool: this.mempool,
|
|
address: this.config.array('coinbase-address'),
|
|
coinbaseFlags: this.config.str('coinbase-flags'),
|
|
preverify: this.config.bool('preverify'),
|
|
minWeight: this.config.uint('min-weight'),
|
|
maxWeight: this.config.uint('max-weight'),
|
|
reservedWeight: this.config.uint('reserved-weight'),
|
|
reservedSigops: this.config.uint('reserved-sigops')
|
|
});
|
|
|
|
// RPC needs access to the node.
|
|
this.rpc = new RPC(this);
|
|
|
|
// HTTP needs access to the node.
|
|
this.http = new HTTP({
|
|
network: this.network,
|
|
logger: this.logger,
|
|
node: this,
|
|
prefix: this.config.prefix,
|
|
ssl: this.config.bool('ssl'),
|
|
keyFile: this.config.path('ssl-key'),
|
|
certFile: this.config.path('ssl-cert'),
|
|
host: this.config.str('http-host'),
|
|
port: this.config.uint('http-port'),
|
|
apiKey: this.config.str('api-key'),
|
|
noAuth: this.config.bool('no-auth'),
|
|
cors: this.config.bool('cors')
|
|
});
|
|
|
|
if (!this.config.bool('no-dns')) {
|
|
const publicHost = this.config.str('public-host');
|
|
|
|
this.ns = new RootServer({
|
|
logger: this.logger,
|
|
key: this.identityKey,
|
|
host: this.config.str('ns-host'),
|
|
port: this.config.uint('ns-port', this.network.nsPort),
|
|
lookup: key => this.chain.db.tree.get(key),
|
|
publicHost: this.config.str('ns-public-host', publicHost),
|
|
noSig0: this.config.bool('no-sig0')
|
|
});
|
|
|
|
if (!this.config.bool('no-rs')) {
|
|
this.rs = new RecursiveServer({
|
|
logger: this.logger,
|
|
key: this.identityKey,
|
|
host: this.config.str('rs-host'),
|
|
port: this.config.uint('rs-port', this.network.rsPort),
|
|
stubHost: this.ns.host,
|
|
stubPort: this.ns.port,
|
|
noUnbound: this.config.bool('rs-no-unbound'),
|
|
noSig0: this.config.bool('no-sig0')
|
|
});
|
|
}
|
|
}
|
|
|
|
this.init();
|
|
}
|
|
|
|
/**
|
|
* Initialize the node.
|
|
* @private
|
|
*/
|
|
|
|
init() {
|
|
// Bind to errors
|
|
this.chain.on('error', err => this.error(err));
|
|
this.chain.on('abort', err => this.abort(err));
|
|
|
|
this.mempool.on('error', err => this.error(err));
|
|
this.pool.on('error', err => this.error(err));
|
|
this.miner.on('error', err => this.error(err));
|
|
|
|
if (this.http)
|
|
this.http.on('error', err => this.error(err));
|
|
|
|
this.mempool.on('tx', (tx) => {
|
|
this.miner.cpu.notifyEntry();
|
|
this.emit('tx', tx);
|
|
});
|
|
|
|
this.mempool.on('claim', (claim) => {
|
|
this.miner.cpu.notifyEntry();
|
|
this.emit('claim', claim);
|
|
});
|
|
|
|
this.mempool.on('airdrop', (proof) => {
|
|
this.miner.cpu.notifyEntry();
|
|
this.emit('airdrop', proof);
|
|
});
|
|
|
|
this.chain.on('connect', async (entry, block, view) => {
|
|
try {
|
|
await this.mempool._addBlock(entry, block.txs, view);
|
|
} catch (e) {
|
|
this.error(e);
|
|
}
|
|
this.emit('block', block);
|
|
this.emit('connect', entry, block);
|
|
});
|
|
|
|
this.chain.on('disconnect', async (entry, block) => {
|
|
try {
|
|
await this.mempool._removeBlock(entry, block.txs);
|
|
} catch (e) {
|
|
this.error(e);
|
|
}
|
|
this.emit('disconnect', entry, block);
|
|
});
|
|
|
|
this.chain.on('reorganize', async (tip, competitor, fork) => {
|
|
try {
|
|
await this.mempool._handleReorg();
|
|
} catch (e) {
|
|
this.error(e);
|
|
}
|
|
this.emit('reorganize', tip, competitor, fork);
|
|
});
|
|
|
|
this.chain.on('reset', async (tip) => {
|
|
try {
|
|
await this.mempool._reset();
|
|
} catch (e) {
|
|
this.error(e);
|
|
}
|
|
this.emit('reset', tip);
|
|
});
|
|
|
|
this.chain.on('tree compact start', (treeRoot, entry) => {
|
|
this.emit('tree compact start', treeRoot, entry);
|
|
});
|
|
|
|
this.chain.on('tree compact end', (treeRoot, entry) => {
|
|
this.emit('tree compact end', treeRoot, entry);
|
|
});
|
|
|
|
this.chain.on('tree reconstruct start', () => {
|
|
this.emit('tree reconstruct start');
|
|
});
|
|
|
|
this.chain.on('tree reconstruct end', () => {
|
|
this.emit('tree reconstruct end');
|
|
});
|
|
|
|
this.loadPlugins();
|
|
}
|
|
|
|
/**
|
|
* Open the node and all its child objects,
|
|
* wait for the database to load.
|
|
* @alias FullNode#open
|
|
* @returns {Promise}
|
|
*/
|
|
|
|
async open() {
|
|
assert(!this.opened, 'FullNode is already open.');
|
|
this.opened = true;
|
|
|
|
await this.handlePreopen();
|
|
await this.blocks.open();
|
|
await this.chain.open();
|
|
await this.mempool.open();
|
|
await this.miner.open();
|
|
await this.pool.open();
|
|
|
|
await this.openPlugins();
|
|
|
|
await this.http.open();
|
|
|
|
if (this.ns)
|
|
await this.ns.open();
|
|
|
|
if (this.rs)
|
|
await this.rs.open();
|
|
|
|
await this.handleOpen();
|
|
|
|
if (this.has('walletdb')) {
|
|
const {wdb} = this.require('walletdb');
|
|
if (this.miner.addresses.length === 0) {
|
|
const addr = await wdb.primary.receiveAddress();
|
|
this.miner.addresses.push(addr);
|
|
}
|
|
}
|
|
|
|
this.logger.info('Node is loaded.');
|
|
this.emit('open');
|
|
}
|
|
|
|
/**
|
|
* Close the node, wait for the database to close.
|
|
* @alias FullNode#close
|
|
* @returns {Promise}
|
|
*/
|
|
|
|
async close() {
|
|
assert(this.opened, 'FullNode is not open.');
|
|
this.opened = false;
|
|
|
|
await this.handlePreclose();
|
|
await this.http.close();
|
|
|
|
if (this.rs)
|
|
await this.rs.close();
|
|
|
|
if (this.ns)
|
|
await this.ns.close();
|
|
|
|
await this.closePlugins();
|
|
|
|
await this.pool.close();
|
|
await this.miner.close();
|
|
await this.mempool.close();
|
|
await this.chain.close();
|
|
await this.blocks.close();
|
|
await this.handleClose();
|
|
|
|
this.logger.info('Node is closed.');
|
|
this.emit('closed');
|
|
this.emit('close');
|
|
}
|
|
|
|
/**
|
|
* Rescan for any missed transactions.
|
|
* @param {Number|Hash} start - Start block.
|
|
* @param {BloomFilter} filter
|
|
* @param {Function} iter - Iterator.
|
|
* @returns {Promise}
|
|
*/
|
|
|
|
scan(start, filter, iter) {
|
|
return this.chain.scan(start, filter, iter);
|
|
}
|
|
|
|
/**
|
|
* Interactive rescan for any missed transactions.
|
|
* @param {Number|Hash} start - Start block.
|
|
* @param {BloomFilter} filter
|
|
* @param {Function} iter - Iterator.
|
|
* @param {Boolean} [fullLock=false] - lock the whole chain instead of per
|
|
* scan.
|
|
* @returns {Promise}
|
|
*/
|
|
|
|
scanInteractive(start, filter, iter, fullLock = false) {
|
|
return this.chain.scanInteractive(start, filter, iter, fullLock);
|
|
}
|
|
|
|
/**
|
|
* Broadcast a transaction.
|
|
* @param {TX|Block|Claim|AirdropProof} item
|
|
* @returns {Promise}
|
|
*/
|
|
|
|
async broadcast(item) {
|
|
try {
|
|
await this.pool.broadcast(item);
|
|
} catch (e) {
|
|
this.emit('error', e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add transaction to mempool, broadcast.
|
|
* @param {TX} tx
|
|
*/
|
|
|
|
async sendTX(tx) {
|
|
let missing;
|
|
|
|
try {
|
|
missing = await this.mempool.addTX(tx);
|
|
} catch (err) {
|
|
if (err.type === 'VerifyError' && err.score === 0) {
|
|
this.error(err);
|
|
this.logger.warning('Verification failed for tx: %x.', tx.hash());
|
|
this.logger.warning('Attempting to broadcast anyway...');
|
|
this.broadcast(tx);
|
|
return;
|
|
}
|
|
throw err;
|
|
}
|
|
|
|
if (missing) {
|
|
this.logger.warning('TX was orphaned in mempool: %x.', tx.hash());
|
|
this.logger.warning('Attempting to broadcast anyway...');
|
|
this.broadcast(tx);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add transaction to mempool, broadcast. Silence errors.
|
|
* @param {TX} tx
|
|
* @returns {Promise}
|
|
*/
|
|
|
|
async relay(tx) {
|
|
try {
|
|
await this.sendTX(tx);
|
|
} catch (e) {
|
|
this.error(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add claim to mempool, broadcast.
|
|
* @param {Claim} claim
|
|
*/
|
|
|
|
async sendClaim(claim) {
|
|
try {
|
|
await this.mempool.addClaim(claim);
|
|
} catch (err) {
|
|
if (err.type === 'VerifyError' && err.score === 0) {
|
|
this.error(err);
|
|
this.logger.warning('Verification failed for claim: %x.', claim.hash());
|
|
this.logger.warning('Attempting to broadcast anyway...');
|
|
this.broadcast(claim);
|
|
return;
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add claim to mempool, broadcast. Silence errors.
|
|
* @param {Claim} claim
|
|
* @returns {Promise}
|
|
*/
|
|
|
|
async relayClaim(claim) {
|
|
try {
|
|
await this.sendClaim(claim);
|
|
} catch (e) {
|
|
this.error(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add airdrop proof to mempool, broadcast.
|
|
* @param {AirdropProof} proof
|
|
*/
|
|
|
|
async sendAirdrop(proof) {
|
|
try {
|
|
await this.mempool.addAirdrop(proof);
|
|
} catch (err) {
|
|
if (err.type === 'VerifyError' && err.score === 0) {
|
|
this.error(err);
|
|
this.logger.warning('Verification failed for proof: %x.', proof.hash());
|
|
this.logger.warning('Attempting to broadcast anyway...');
|
|
this.broadcast(proof);
|
|
return;
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add airdrop proof to mempool, broadcast. Silence errors.
|
|
* @param {AirdropProof} proof
|
|
* @returns {Promise}
|
|
*/
|
|
|
|
async relayAirdrop(proof) {
|
|
try {
|
|
await this.sendAirdrop(proof);
|
|
} catch (e) {
|
|
this.error(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Connect to the network.
|
|
* @returns {Promise}
|
|
*/
|
|
|
|
connect() {
|
|
return this.pool.connect();
|
|
}
|
|
|
|
/**
|
|
* Disconnect from the network.
|
|
* @returns {Promise}
|
|
*/
|
|
|
|
disconnect() {
|
|
return this.pool.disconnect();
|
|
}
|
|
|
|
/**
|
|
* Start the blockchain sync.
|
|
*/
|
|
|
|
startSync() {
|
|
return this.pool.startSync();
|
|
}
|
|
|
|
/**
|
|
* Stop syncing the blockchain.
|
|
*/
|
|
|
|
stopSync() {
|
|
return this.pool.stopSync();
|
|
}
|
|
|
|
/**
|
|
* Retrieve a block from the chain database.
|
|
* @param {Hash} hash
|
|
* @returns {Promise} - Returns {@link Block}.
|
|
*/
|
|
|
|
getBlock(hash) {
|
|
return this.chain.getBlock(hash);
|
|
}
|
|
|
|
/**
|
|
* Retrieve a coin from the mempool or chain database.
|
|
* Takes into account spent coins in the mempool.
|
|
* @param {Hash} hash
|
|
* @param {Number} index
|
|
* @returns {Promise} - Returns {@link Coin}.
|
|
*/
|
|
|
|
async getCoin(hash, index) {
|
|
const coin = this.mempool.getCoin(hash, index);
|
|
|
|
if (coin)
|
|
return coin;
|
|
|
|
if (this.mempool.isSpent(hash, index))
|
|
return null;
|
|
|
|
return this.chain.getCoin(hash, index);
|
|
}
|
|
|
|
/**
|
|
* Get coins that pertain to an address from the mempool or chain database.
|
|
* Takes into account spent coins in the mempool.
|
|
* @param {Address} addrs
|
|
* @returns {Promise} - Returns {@link Coin}[].
|
|
*/
|
|
|
|
async getCoinsByAddress(addrs) {
|
|
const mempool = this.mempool.getCoinsByAddress(addrs);
|
|
const chain = await this.chain.getCoinsByAddress(addrs);
|
|
const out = [];
|
|
|
|
for (const coin of chain) {
|
|
const spent = this.mempool.isSpent(coin.hash, coin.index);
|
|
|
|
if (spent)
|
|
continue;
|
|
|
|
out.push(coin);
|
|
}
|
|
|
|
for (const coin of mempool)
|
|
out.push(coin);
|
|
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* Retrieve transactions pertaining to an
|
|
* address from the mempool or chain database.
|
|
* @param {Address} addrs
|
|
* @returns {Promise} - Returns {@link TXMeta}[].
|
|
*/
|
|
|
|
async getMetaByAddress(addrs) {
|
|
const mempool = this.mempool.getMetaByAddress(addrs);
|
|
const chain = await this.chain.getMetaByAddress(addrs);
|
|
return chain.concat(mempool);
|
|
}
|
|
|
|
/**
|
|
* Retrieve a transaction from the mempool or chain database.
|
|
* @param {Hash} hash
|
|
* @returns {Promise} - Returns {@link TXMeta}.
|
|
*/
|
|
|
|
async getMeta(hash) {
|
|
const meta = this.mempool.getMeta(hash);
|
|
|
|
if (meta)
|
|
return meta;
|
|
|
|
return this.chain.getMeta(hash);
|
|
}
|
|
|
|
/**
|
|
* Retrieve a spent coin viewpoint from mempool or chain database.
|
|
* @param {TXMeta} meta
|
|
* @returns {Promise} - Returns {@link CoinView}.
|
|
*/
|
|
|
|
async getMetaView(meta) {
|
|
if (meta.height === -1)
|
|
return this.mempool.getSpentView(meta.tx);
|
|
return this.chain.getSpentView(meta.tx);
|
|
}
|
|
|
|
/**
|
|
* Retrieve transactions pertaining to an
|
|
* address from the mempool or chain database.
|
|
* @param {Address} addrs
|
|
* @returns {Promise} - Returns {@link TX}[].
|
|
*/
|
|
|
|
async getTXByAddress(addrs) {
|
|
const mtxs = await this.getMetaByAddress(addrs);
|
|
const out = [];
|
|
|
|
for (const mtx of mtxs)
|
|
out.push(mtx.tx);
|
|
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* Retrieve a transaction from the mempool or chain database.
|
|
* @param {Hash} hash
|
|
* @returns {Promise} - Returns {@link TX}.
|
|
*/
|
|
|
|
async getTX(hash) {
|
|
const mtx = await this.getMeta(hash);
|
|
|
|
if (!mtx)
|
|
return null;
|
|
|
|
return mtx.tx;
|
|
}
|
|
|
|
/**
|
|
* Test whether the mempool or chain contains a transaction.
|
|
* @param {Hash} hash
|
|
* @returns {Promise} - Returns Boolean.
|
|
*/
|
|
|
|
async hasTX(hash) {
|
|
if (this.mempool.hasEntry(hash))
|
|
return true;
|
|
|
|
return this.chain.hasTX(hash);
|
|
}
|
|
|
|
/**
|
|
* Get current name state.
|
|
* @param {Buffer} nameHash
|
|
* @returns {NameState}
|
|
*/
|
|
|
|
async getNameStatus(nameHash) {
|
|
const height = this.chain.height + 1;
|
|
return this.chain.db.getNameStatus(nameHash, height);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Expose
|
|
*/
|
|
|
|
module.exports = FullNode;
|