1612 lines
49 KiB
JavaScript
1612 lines
49 KiB
JavaScript
'use strict';
|
|
|
|
var fs = require('fs');
|
|
var BaseService = require('../../service');
|
|
var inherits = require('util').inherits;
|
|
var async = require('async');
|
|
var mkdirp = require('mkdirp');
|
|
var index = require('../../');
|
|
var log = index.log;
|
|
var errors = index.errors;
|
|
var bitcore = require('bitcore-lib');
|
|
var Networks = bitcore.Networks;
|
|
var levelup = require('levelup');
|
|
var leveldown = require('leveldown');
|
|
var memdown = require('memdown');
|
|
var $ = bitcore.util.preconditions;
|
|
var _ = bitcore.deps._;
|
|
var Hash = bitcore.crypto.Hash;
|
|
var EventEmitter = require('events').EventEmitter;
|
|
var Address = bitcore.Address;
|
|
var AddressHistory = require('./history');
|
|
var constants = require('./constants');
|
|
var encoding = require('./encoding');
|
|
var InputsTransformStream = require('./streams/inputs-transform');
|
|
var OutputsTransformStream = require('./streams/outputs-transform');
|
|
|
|
|
|
/**
|
|
* The Address Service builds upon the Database Service and the Bitcoin Service to add additional
|
|
* functionality for getting information by base58check encoded addresses. This includes getting the
|
|
* balance for an address, the history for a collection of addresses, and unspent outputs for
|
|
* constructing transactions. This is typically the core functionality for building a wallet.
|
|
* @param {Object} options
|
|
* @param {Node} options.node - An instance of the node
|
|
* @param {String} options.name - An optional name of the service
|
|
*/
|
|
var AddressService = function(options) {
|
|
BaseService.call(this, options);
|
|
|
|
this.subscriptions = {};
|
|
this.subscriptions['address/transaction'] = {};
|
|
this.subscriptions['address/balance'] = {};
|
|
|
|
this._bitcoindTransactionListener = this.transactionHandler.bind(this);
|
|
this._bitcoindTransactionLeaveListener = this.transactionLeaveHandler.bind(this);
|
|
this.node.services.bitcoind.on('tx', this._bitcoindTransactionListener);
|
|
this.node.services.bitcoind.on('txleave', this._bitcoindTransactionLeaveListener);
|
|
|
|
this.maxInputsQueryLength = options.maxInputsQueryLength || constants.MAX_INPUTS_QUERY_LENGTH;
|
|
this.maxOutputsQueryLength = options.maxOutputsQueryLength || constants.MAX_OUTPUTS_QUERY_LENGTH;
|
|
|
|
this._setMempoolIndexPath();
|
|
if (options.mempoolMemoryIndex) {
|
|
this.levelupStore = memdown;
|
|
} else {
|
|
this.levelupStore = leveldown;
|
|
}
|
|
this.mempoolIndex = null; // Used for larger mempool indexes
|
|
this.mempoolSpentIndex = {}; // Used for small quick synchronous lookups
|
|
this.mempoolAddressIndex = {}; // Used to check if an address is on the spend pool
|
|
};
|
|
|
|
inherits(AddressService, BaseService);
|
|
|
|
AddressService.dependencies = [
|
|
'bitcoind',
|
|
'db'
|
|
];
|
|
|
|
AddressService.prototype.start = function(callback) {
|
|
var self = this;
|
|
|
|
async.series([
|
|
|
|
function(next) {
|
|
// Flush any existing mempool index
|
|
if (fs.existsSync(self.mempoolIndexPath)) {
|
|
leveldown.destroy(self.mempoolIndexPath, next);
|
|
} else {
|
|
setImmediate(next);
|
|
}
|
|
},
|
|
function(next) {
|
|
// Setup new mempool index
|
|
if (!fs.existsSync(self.mempoolIndexPath)) {
|
|
mkdirp(self.mempoolIndexPath, next);
|
|
} else {
|
|
setImmediate(next);
|
|
}
|
|
},
|
|
function(next) {
|
|
self.mempoolIndex = levelup(
|
|
self.mempoolIndexPath,
|
|
{
|
|
db: self.levelupStore,
|
|
keyEncoding: 'binary',
|
|
valueEncoding: 'binary',
|
|
fillCache: false,
|
|
maxOpenFiles: 200
|
|
},
|
|
next
|
|
);
|
|
}
|
|
], callback);
|
|
|
|
};
|
|
|
|
AddressService.prototype.stop = function(callback) {
|
|
// TODO Keep track of ongoing db requests before shutting down
|
|
this.node.services.bitcoind.removeListener('tx', this._bitcoindTransactionListener);
|
|
this.node.services.bitcoind.removeListener('txleave', this._bitcoindTransactionLeaveListener);
|
|
this.mempoolIndex.close(callback);
|
|
};
|
|
|
|
/**
|
|
* This function will set `this.mempoolIndexPath` based on `this.node.network`.
|
|
* @private
|
|
*/
|
|
AddressService.prototype._setMempoolIndexPath = function() {
|
|
this.mempoolIndexPath = this._getDBPathFor('bitcore-addressmempool.db');
|
|
};
|
|
|
|
AddressService.prototype._getDBPathFor = function(dbname) {
|
|
$.checkState(this.node.datadir, 'Node is expected to have a "datadir" property');
|
|
var path;
|
|
if (this.node.network === Networks.livenet) {
|
|
path = this.node.datadir + '/' + dbname;
|
|
} else if (this.node.network === Networks.testnet) {
|
|
if (this.node.network.regtestEnabled) {
|
|
path = this.node.datadir + '/regtest/' + dbname;
|
|
} else {
|
|
path = this.node.datadir + '/testnet3/' + dbname;
|
|
}
|
|
} else {
|
|
throw new Error('Unknown network: ' + this.network);
|
|
}
|
|
return path;
|
|
};
|
|
|
|
/**
|
|
* Called by the Node to get the available API methods for this service,
|
|
* that can be exposed over the JSON-RPC interface.
|
|
*/
|
|
AddressService.prototype.getAPIMethods = function() {
|
|
return [
|
|
['getBalance', this, this.getBalance, 2],
|
|
['getOutputs', this, this.getOutputs, 2],
|
|
['getUnspentOutputs', this, this.getUnspentOutputs, 2],
|
|
['getInputForOutput', this, this.getInputForOutput, 2],
|
|
['isSpent', this, this.isSpent, 2],
|
|
['getAddressHistory', this, this.getAddressHistory, 2],
|
|
['getAddressSummary', this, this.getAddressSummary, 1]
|
|
];
|
|
};
|
|
|
|
/**
|
|
* Called by the Bus to get the available events for this service.
|
|
*/
|
|
AddressService.prototype.getPublishEvents = function() {
|
|
return [
|
|
{
|
|
name: 'address/transaction',
|
|
scope: this,
|
|
subscribe: this.subscribe.bind(this, 'address/transaction'),
|
|
unsubscribe: this.unsubscribe.bind(this, 'address/transaction')
|
|
},
|
|
{
|
|
name: 'address/balance',
|
|
scope: this,
|
|
subscribe: this.subscribe.bind(this, 'address/balance'),
|
|
unsubscribe: this.unsubscribe.bind(this, 'address/balance')
|
|
}
|
|
];
|
|
};
|
|
|
|
/**
|
|
* Will process each output of a transaction from the daemon "tx" event, and construct
|
|
* an object with the data for the message to be relayed to any subscribers for an address.
|
|
*
|
|
* @param {Object} messages - An object to collect messages
|
|
* @param {Transaction} tx - Instance of the transaction
|
|
* @param {Number} outputIndex - The index of the output in the transaction
|
|
* @param {Boolean} rejected - If the transaction was rejected by the mempool
|
|
*/
|
|
AddressService.prototype.transactionOutputHandler = function(messages, tx, outputIndex, rejected) {
|
|
var script = tx.outputs[outputIndex].script;
|
|
|
|
// If the script is invalid skip
|
|
if (!script) {
|
|
return;
|
|
}
|
|
|
|
var addressInfo = encoding.extractAddressInfoFromScript(script, this.node.network);
|
|
if (!addressInfo) {
|
|
return;
|
|
}
|
|
|
|
addressInfo.hashHex = addressInfo.hashBuffer.toString('hex');
|
|
|
|
// Collect data to publish to address subscribers
|
|
if (messages[addressInfo.hashHex]) {
|
|
messages[addressInfo.hashHex].outputIndexes.push(outputIndex);
|
|
} else {
|
|
messages[addressInfo.hashHex] = {
|
|
tx: tx,
|
|
outputIndexes: [outputIndex],
|
|
addressInfo: addressInfo,
|
|
rejected: rejected
|
|
};
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This will handle data from the daemon "txleave" that a transaction has left the mempool.
|
|
* @param {Object} txInfo - The data from the daemon.on('txleave') event
|
|
* @param {Buffer} txInfo.buffer - The transaction buffer
|
|
* @param {String} txInfo.hash - The hash of the transaction
|
|
*/
|
|
AddressService.prototype.transactionLeaveHandler = function(txInfo) {
|
|
var tx = bitcore.Transaction().fromBuffer(txInfo.buffer);
|
|
this.updateMempoolIndex(tx, false);
|
|
};
|
|
|
|
/**
|
|
* This will handle data from the daemon "tx" event, go through each of the outputs
|
|
* and send messages by calling `transactionEventHandler` to any subscribers for a
|
|
* particular address.
|
|
* @param {Object} txInfo - The data from the daemon.on('tx') event
|
|
* @param {Buffer} txInfo.buffer - The transaction buffer
|
|
* @param {Boolean} txInfo.mempool - If the transaction was accepted in the mempool
|
|
* @param {String} txInfo.hash - The hash of the transaction
|
|
* @param {Function} [callback] - Optional callback
|
|
*/
|
|
AddressService.prototype.transactionHandler = function(txInfo, callback) {
|
|
var self = this;
|
|
|
|
if (!callback) {
|
|
callback = function(err) {
|
|
if (err) {
|
|
return log.error(err);
|
|
}
|
|
};
|
|
}
|
|
|
|
if (this.node.stopping) {
|
|
return callback();
|
|
}
|
|
|
|
// Basic transaction format is handled by the daemon
|
|
// and we can safely assume the buffer is properly formatted.
|
|
var tx = bitcore.Transaction().fromBuffer(txInfo.buffer);
|
|
|
|
var messages = {};
|
|
|
|
var outputsLength = tx.outputs.length;
|
|
for (var i = 0; i < outputsLength; i++) {
|
|
this.transactionOutputHandler(messages, tx, i, !txInfo.mempool);
|
|
}
|
|
|
|
function finish(err) {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
for (var key in messages) {
|
|
self.transactionEventHandler(messages[key]);
|
|
self.balanceEventHandler(null, messages[key].addressInfo);
|
|
}
|
|
callback();
|
|
}
|
|
|
|
if (txInfo.mempool) {
|
|
self.updateMempoolIndex(tx, true, finish);
|
|
} else {
|
|
setImmediate(finish);
|
|
}
|
|
|
|
};
|
|
|
|
AddressService.prototype._updateAddressIndex = function(key, add) {
|
|
var currentValue = this.mempoolAddressIndex[key] || 0;
|
|
|
|
if(add) {
|
|
if (currentValue > 0) {
|
|
this.mempoolAddressIndex[key] = currentValue + 1;
|
|
} else {
|
|
this.mempoolAddressIndex[key] = 1;
|
|
}
|
|
} else {
|
|
if (currentValue <= 1) {
|
|
delete this.mempoolAddressIndex[key];
|
|
} else {
|
|
this.mempoolAddressIndex[key]--;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* This function will update the mempool address index with the necessary
|
|
* information for further lookups.
|
|
* @param {Transaction} - An instance of a Bitcore Transaction
|
|
* @param {Boolean} - Add/remove from the index
|
|
*/
|
|
AddressService.prototype.updateMempoolIndex = function(tx, add, callback) {
|
|
/* jshint maxstatements: 100 */
|
|
|
|
var operations = [];
|
|
var timestampBuffer = new Buffer(new Array(8));
|
|
timestampBuffer.writeDoubleBE(new Date().getTime());
|
|
|
|
var action = 'put';
|
|
if (!add) {
|
|
action = 'del';
|
|
}
|
|
|
|
var txid = tx.hash;
|
|
var txidBuffer = new Buffer(txid, 'hex');
|
|
|
|
var outputLength = tx.outputs.length;
|
|
for (var outputIndex = 0; outputIndex < outputLength; outputIndex++) {
|
|
var output = tx.outputs[outputIndex];
|
|
if (!output.script) {
|
|
continue;
|
|
}
|
|
var addressInfo = encoding.extractAddressInfoFromScript(output.script, this.node.network);
|
|
if (!addressInfo) {
|
|
continue;
|
|
}
|
|
|
|
var addressIndexKey = encoding.encodeMempoolAddressIndexKey(addressInfo.hashBuffer, addressInfo.hashTypeBuffer);
|
|
|
|
this._updateAddressIndex(addressIndexKey, add);
|
|
|
|
// Update output index
|
|
var outputIndexBuffer = new Buffer(4);
|
|
outputIndexBuffer.writeUInt32BE(outputIndex);
|
|
|
|
var outKey = Buffer.concat([
|
|
constants.MEMPREFIXES.OUTPUTS,
|
|
addressInfo.hashBuffer,
|
|
addressInfo.hashTypeBuffer,
|
|
txidBuffer,
|
|
outputIndexBuffer
|
|
]);
|
|
|
|
var outValue = encoding.encodeOutputMempoolValue(
|
|
output.satoshis,
|
|
timestampBuffer,
|
|
output._scriptBuffer
|
|
);
|
|
|
|
operations.push({
|
|
type: action,
|
|
key: outKey,
|
|
value: outValue
|
|
});
|
|
|
|
}
|
|
var inputLength = tx.inputs.length;
|
|
for (var inputIndex = 0; inputIndex < inputLength; inputIndex++) {
|
|
|
|
var input = tx.inputs[inputIndex];
|
|
|
|
var inputOutputIndexBuffer = new Buffer(4);
|
|
inputOutputIndexBuffer.writeUInt32BE(input.outputIndex);
|
|
|
|
// Add an additional small spent index for fast synchronous lookups
|
|
var spentIndexSyncKey = encoding.encodeSpentIndexSyncKey(
|
|
input.prevTxId,
|
|
input.outputIndex
|
|
);
|
|
if (add) {
|
|
this.mempoolSpentIndex[spentIndexSyncKey] = true;
|
|
} else {
|
|
delete this.mempoolSpentIndex[spentIndexSyncKey];
|
|
}
|
|
|
|
// Add a more detailed spent index with values
|
|
var spentIndexKey = Buffer.concat([
|
|
constants.MEMPREFIXES.SPENTSMAP,
|
|
input.prevTxId,
|
|
inputOutputIndexBuffer
|
|
]);
|
|
var inputIndexBuffer = new Buffer(4);
|
|
inputIndexBuffer.writeUInt32BE(inputIndex);
|
|
var inputIndexValue = Buffer.concat([
|
|
txidBuffer,
|
|
inputIndexBuffer
|
|
]);
|
|
operations.push({
|
|
type: action,
|
|
key: spentIndexKey,
|
|
value: inputIndexValue
|
|
});
|
|
|
|
// Update input index
|
|
var inputHashBuffer;
|
|
var inputHashType;
|
|
if (input.script.isPublicKeyHashIn()) {
|
|
inputHashBuffer = Hash.sha256ripemd160(input.script.chunks[1].buf);
|
|
inputHashType = constants.HASH_TYPES.PUBKEY;
|
|
} else if (input.script.isScriptHashIn()) {
|
|
inputHashBuffer = Hash.sha256ripemd160(input.script.chunks[input.script.chunks.length - 1].buf);
|
|
inputHashType = constants.HASH_TYPES.REDEEMSCRIPT;
|
|
} else {
|
|
continue;
|
|
}
|
|
var inputKey = Buffer.concat([
|
|
constants.MEMPREFIXES.SPENTS,
|
|
inputHashBuffer,
|
|
inputHashType,
|
|
input.prevTxId,
|
|
inputOutputIndexBuffer
|
|
]);
|
|
var inputValue = Buffer.concat([
|
|
txidBuffer,
|
|
inputIndexBuffer,
|
|
timestampBuffer
|
|
]);
|
|
operations.push({
|
|
type: action,
|
|
key: inputKey,
|
|
value: inputValue
|
|
});
|
|
|
|
var addressIndexKey = encoding.encodeMempoolAddressIndexKey(inputHashBuffer, inputHashType);
|
|
|
|
this._updateAddressIndex(addressIndexKey, add);
|
|
}
|
|
|
|
if (!callback) {
|
|
callback = function(err) {
|
|
if (err) {
|
|
return log.error(err);
|
|
}
|
|
};
|
|
}
|
|
|
|
this.mempoolIndex.batch(operations, callback);
|
|
};
|
|
|
|
/**
|
|
* The Database Service will run this function when blocks are connected and
|
|
* disconnected to the chain during syncing and reorganizations.
|
|
* @param {Block} block - An instance of a Bitcore Block
|
|
* @param {Boolean} addOutput - If the block is being removed or added to the chain
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.blockHandler = function(block, addOutput, callback) {
|
|
var txs = block.transactions;
|
|
var height = block.__height;
|
|
|
|
var action = 'put';
|
|
if (!addOutput) {
|
|
action = 'del';
|
|
}
|
|
|
|
var operations = [];
|
|
|
|
var transactionLength = txs.length;
|
|
for (var i = 0; i < transactionLength; i++) {
|
|
|
|
var tx = txs[i];
|
|
var txid = tx.id;
|
|
var txidBuffer = new Buffer(txid, 'hex');
|
|
var inputs = tx.inputs;
|
|
var outputs = tx.outputs;
|
|
|
|
// Subscription messages
|
|
var txmessages = {};
|
|
|
|
var outputLength = outputs.length;
|
|
for (var outputIndex = 0; outputIndex < outputLength; outputIndex++) {
|
|
var output = outputs[outputIndex];
|
|
|
|
var script = output.script;
|
|
|
|
if(!script) {
|
|
log.debug('Invalid script');
|
|
continue;
|
|
}
|
|
|
|
var addressInfo = encoding.extractAddressInfoFromScript(script, this.node.network);
|
|
if (!addressInfo) {
|
|
continue;
|
|
}
|
|
|
|
// We need to use the height for indexes (and not the timestamp) because the
|
|
// the timestamp has unreliable sequential ordering. The next block
|
|
// can have a time that is previous to the previous block (however not
|
|
// less than the mean of the 11 previous blocks) and not greater than 2
|
|
// hours in the future.
|
|
var key = encoding.encodeOutputKey(addressInfo.hashBuffer, addressInfo.hashTypeBuffer,
|
|
height, txidBuffer, outputIndex);
|
|
var value = encoding.encodeOutputValue(output.satoshis, output._scriptBuffer);
|
|
operations.push({
|
|
type: action,
|
|
key: key,
|
|
value: value
|
|
});
|
|
|
|
addressInfo.hashHex = addressInfo.hashBuffer.toString('hex');
|
|
|
|
// Collect data for subscribers
|
|
if (txmessages[addressInfo.hashHex]) {
|
|
txmessages[addressInfo.hashHex].outputIndexes.push(outputIndex);
|
|
} else {
|
|
txmessages[addressInfo.hashHex] = {
|
|
tx: tx,
|
|
height: height,
|
|
outputIndexes: [outputIndex],
|
|
addressInfo: addressInfo,
|
|
timestamp: block.header.timestamp
|
|
};
|
|
}
|
|
|
|
this.balanceEventHandler(block, addressInfo);
|
|
|
|
}
|
|
|
|
// Publish events to any subscribers for this transaction
|
|
for (var addressKey in txmessages) {
|
|
this.transactionEventHandler(txmessages[addressKey]);
|
|
}
|
|
|
|
if(tx.isCoinbase()) {
|
|
continue;
|
|
}
|
|
|
|
for(var inputIndex = 0; inputIndex < inputs.length; inputIndex++) {
|
|
|
|
var input = inputs[inputIndex];
|
|
var inputHash;
|
|
var inputHashType;
|
|
|
|
if (input.script.isPublicKeyHashIn()) {
|
|
inputHash = Hash.sha256ripemd160(input.script.chunks[1].buf);
|
|
inputHashType = constants.HASH_TYPES.PUBKEY;
|
|
} else if (input.script.isScriptHashIn()) {
|
|
inputHash = Hash.sha256ripemd160(input.script.chunks[input.script.chunks.length - 1].buf);
|
|
inputHashType = constants.HASH_TYPES.REDEEMSCRIPT;
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
var prevTxIdBuffer = new Buffer(input.prevTxId, 'hex');
|
|
|
|
// To be able to query inputs by address and spent height
|
|
var inputKey = encoding.encodeInputKey(inputHash, inputHashType, height, prevTxIdBuffer, input.outputIndex);
|
|
var inputValue = encoding.encodeInputValue(txidBuffer, inputIndex);
|
|
|
|
operations.push({
|
|
type: action,
|
|
key: inputKey,
|
|
value: inputValue
|
|
});
|
|
|
|
// To be able to search for an input spending an output
|
|
var inputKeyMap = encoding.encodeInputKeyMap(prevTxIdBuffer, input.outputIndex);
|
|
var inputValueMap = encoding.encodeInputValueMap(txidBuffer, inputIndex);
|
|
|
|
operations.push({
|
|
type: action,
|
|
key: inputKeyMap,
|
|
value: inputValueMap
|
|
});
|
|
|
|
}
|
|
}
|
|
|
|
setImmediate(function() {
|
|
callback(null, operations);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* This function is responsible for emitting events to any subscribers to the
|
|
* `address/transaction` event.
|
|
* @param {Object} obj
|
|
* @param {Transaction} obj.tx - The transaction
|
|
* @param {Object} obj.addressInfo
|
|
* @param {String} obj.addressInfo.hashHex - The hex string of address hash for the subscription
|
|
* @param {String} obj.addressInfo.hashBuffer - The address hash buffer
|
|
* @param {String} obj.addressInfo.addressType - The address type
|
|
* @param {Array} obj.outputIndexes - Indexes of the inputs that includes the address
|
|
* @param {Array} obj.inputIndexes - Indexes of the outputs that includes the address
|
|
* @param {Date} obj.timestamp - The time of the block the transaction was included
|
|
* @param {Number} obj.height - The height of the block the transaction was included
|
|
* @param {Boolean} obj.rejected - If the transaction was not accepted in the mempool
|
|
*/
|
|
AddressService.prototype.transactionEventHandler = function(obj) {
|
|
if(this.subscriptions['address/transaction'][obj.addressInfo.hashHex]) {
|
|
var emitters = this.subscriptions['address/transaction'][obj.addressInfo.hashHex];
|
|
var address = new Address({
|
|
hashBuffer: obj.addressInfo.hashBuffer,
|
|
network: this.node.network,
|
|
type: obj.addressInfo.addressType
|
|
});
|
|
for(var i = 0; i < emitters.length; i++) {
|
|
emitters[i].emit('address/transaction', {
|
|
rejected: obj.rejected,
|
|
height: obj.height,
|
|
timestamp: obj.timestamp,
|
|
inputIndexes: obj.inputIndexes,
|
|
outputIndexes: obj.outputIndexes,
|
|
address: address,
|
|
tx: obj.tx
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The function is responsible for emitting events to any subscribers for the
|
|
* `address/balance` event.
|
|
* @param {Block} block
|
|
* @param {Object} obj
|
|
* @param {String} obj.hashHex
|
|
* @param {Buffer} obj.hashBuffer
|
|
* @param {String} obj.addressType
|
|
*/
|
|
AddressService.prototype.balanceEventHandler = function(block, obj) {
|
|
if(this.subscriptions['address/balance'][obj.hashHex]) {
|
|
var emitters = this.subscriptions['address/balance'][obj.hashHex];
|
|
var address = new Address({
|
|
hashBuffer: obj.hashBuffer,
|
|
network: this.node.network,
|
|
type: obj.addressType
|
|
});
|
|
this.getBalance(address, true, function(err, balance) {
|
|
if(err) {
|
|
return this.emit(err);
|
|
}
|
|
for(var i = 0; i < emitters.length; i++) {
|
|
emitters[i].emit('address/balance', address, balance, block);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The Bus will use this function to subscribe to the available
|
|
* events for this service. For information about the available events
|
|
* please see `getPublishEvents`.
|
|
* @param {String} name - The name of the event
|
|
* @param {EventEmitter} emitter - An event emitter instance
|
|
* @param {Array} addresses - An array of addresses to subscribe
|
|
*/
|
|
AddressService.prototype.subscribe = function(name, emitter, addresses) {
|
|
$.checkArgument(emitter instanceof EventEmitter, 'First argument is expected to be an EventEmitter');
|
|
$.checkArgument(Array.isArray(addresses), 'Second argument is expected to be an Array of addresses');
|
|
|
|
for(var i = 0; i < addresses.length; i++) {
|
|
var hashHex = bitcore.Address(addresses[i]).hashBuffer.toString('hex');
|
|
if(!this.subscriptions[name][hashHex]) {
|
|
this.subscriptions[name][hashHex] = [];
|
|
}
|
|
this.subscriptions[name][hashHex].push(emitter);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The Bus will use this function to unsubscribe to the available
|
|
* events for this service.
|
|
* @param {String} name - The name of the event
|
|
* @param {EventEmitter} emitter - An event emitter instance
|
|
* @param {Array} addresses - An array of addresses to subscribe
|
|
*/
|
|
AddressService.prototype.unsubscribe = function(name, emitter, addresses) {
|
|
$.checkArgument(emitter instanceof EventEmitter, 'First argument is expected to be an EventEmitter');
|
|
$.checkArgument(Array.isArray(addresses) || _.isUndefined(addresses), 'Second argument is expected to be an Array of addresses or undefined');
|
|
|
|
if(!addresses) {
|
|
return this.unsubscribeAll(name, emitter);
|
|
}
|
|
|
|
for(var i = 0; i < addresses.length; i++) {
|
|
var hashHex = bitcore.Address(addresses[i]).hashBuffer.toString('hex');
|
|
if(this.subscriptions[name][hashHex]) {
|
|
var emitters = this.subscriptions[name][hashHex];
|
|
var index = emitters.indexOf(emitter);
|
|
if(index > -1) {
|
|
emitters.splice(index, 1);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* A helper function for the `unsubscribe` method to unsubscribe from all addresses.
|
|
* @param {String} name - The name of the event
|
|
* @param {EventEmitter} emitter - An instance of an event emitter
|
|
*/
|
|
AddressService.prototype.unsubscribeAll = function(name, emitter) {
|
|
$.checkArgument(emitter instanceof EventEmitter, 'First argument is expected to be an EventEmitter');
|
|
|
|
for(var hashHex in this.subscriptions[name]) {
|
|
var emitters = this.subscriptions[name][hashHex];
|
|
var index = emitters.indexOf(emitter);
|
|
if(index > -1) {
|
|
emitters.splice(index, 1);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Will sum the total of all unspent outputs to calculate the balance
|
|
* for an address.
|
|
* @param {String} address - The base58check encoded address
|
|
* @param {Boolean} queryMempool - Include mempool in the results
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.getBalance = function(address, queryMempool, callback) {
|
|
this.getUnspentOutputs(address, queryMempool, function(err, outputs) {
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
var satoshis = outputs.map(function(output) {
|
|
return output.satoshis;
|
|
});
|
|
|
|
var sum = satoshis.reduce(function(a, b) {
|
|
return a + b;
|
|
}, 0);
|
|
|
|
return callback(null, sum);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Will give the input that spends an output if it exists with:
|
|
* inputTxId - The input txid hex string
|
|
* inputIndex - A number with the spending input index
|
|
* @param {String|Buffer} txid - The transaction hash with the output
|
|
* @param {Number} outputIndex - The output index in the transaction
|
|
* @param {Object} options
|
|
* @param {Object} options.queryMempool - Include mempool in results
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.getInputForOutput = function(txid, outputIndex, options, callback) {
|
|
$.checkArgument(_.isNumber(outputIndex));
|
|
$.checkArgument(_.isObject(options));
|
|
$.checkArgument(_.isFunction(callback));
|
|
var self = this;
|
|
var txidBuffer;
|
|
if (Buffer.isBuffer(txid)) {
|
|
txidBuffer = txid;
|
|
} else {
|
|
txidBuffer = new Buffer(txid, 'hex');
|
|
}
|
|
if (options.queryMempool) {
|
|
var spentIndexSyncKey = encoding.encodeSpentIndexSyncKey(txidBuffer, outputIndex);
|
|
if (this.mempoolSpentIndex[spentIndexSyncKey]) {
|
|
return this._getSpentMempool(txidBuffer, outputIndex, callback);
|
|
}
|
|
}
|
|
var key = encoding.encodeInputKeyMap(txidBuffer, outputIndex);
|
|
var dbOptions = {
|
|
valueEncoding: 'binary',
|
|
keyEncoding: 'binary'
|
|
};
|
|
this.node.services.db.store.get(key, dbOptions, function(err, buffer) {
|
|
if (err instanceof levelup.errors.NotFoundError) {
|
|
return callback(null, false);
|
|
} else if (err) {
|
|
return callback(err);
|
|
}
|
|
var value = encoding.decodeInputValueMap(buffer);
|
|
callback(null, {
|
|
inputTxId: value.inputTxId.toString('hex'),
|
|
inputIndex: value.inputIndex
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* A streaming equivalent to `getInputs`, and returns a transform stream with data
|
|
* emitted in the same format as `getInputs`.
|
|
*
|
|
* @param {String} addressStr - The relevant address
|
|
* @param {Object} options - Additional options for query the outputs
|
|
* @param {Number} [options.start] - The relevant start block height
|
|
* @param {Number} [options.end] - The relevant end block height
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.createInputsStream = function(addressStr, options) {
|
|
var inputStream = new InputsTransformStream({
|
|
address: new Address(addressStr, this.node.network),
|
|
tipHeight: this.node.services.db.tip.__height
|
|
});
|
|
|
|
var stream = this.createInputsDBStream(addressStr, options)
|
|
.on('error', function(err) {
|
|
// Forward the error
|
|
inputStream.emit('error', err);
|
|
inputStream.end();
|
|
}).pipe(inputStream);
|
|
|
|
return stream;
|
|
|
|
};
|
|
|
|
AddressService.prototype.createInputsDBStream = function(addressStr, options) {
|
|
var stream;
|
|
var addrObj = encoding.getAddressInfo(addressStr);
|
|
var hashBuffer = addrObj.hashBuffer;
|
|
var hashTypeBuffer = addrObj.hashTypeBuffer;
|
|
|
|
if (options.start >= 0 && options.end >= 0) {
|
|
|
|
var endBuffer = new Buffer(4);
|
|
endBuffer.writeUInt32BE(options.end, 0);
|
|
|
|
var startBuffer = new Buffer(4);
|
|
// Because the key has additional data following it, we don't have an ability
|
|
// to use "gte" or "lte" we can only use "gt" and "lt", we therefore need to adjust the number
|
|
// to be one value larger to include it.
|
|
var adjustedStart = options.start + 1;
|
|
startBuffer.writeUInt32BE(adjustedStart, 0);
|
|
|
|
stream = this.node.services.db.store.createReadStream({
|
|
gt: Buffer.concat([
|
|
constants.PREFIXES.SPENTS,
|
|
hashBuffer,
|
|
hashTypeBuffer,
|
|
constants.SPACER_MIN,
|
|
endBuffer
|
|
]),
|
|
lt: Buffer.concat([
|
|
constants.PREFIXES.SPENTS,
|
|
hashBuffer,
|
|
hashTypeBuffer,
|
|
constants.SPACER_MIN,
|
|
startBuffer
|
|
]),
|
|
valueEncoding: 'binary',
|
|
keyEncoding: 'binary'
|
|
});
|
|
} else {
|
|
var allKey = Buffer.concat([constants.PREFIXES.SPENTS, hashBuffer, hashTypeBuffer]);
|
|
stream = this.node.services.db.store.createReadStream({
|
|
gt: Buffer.concat([allKey, constants.SPACER_HEIGHT_MIN]),
|
|
lt: Buffer.concat([allKey, constants.SPACER_HEIGHT_MAX]),
|
|
valueEncoding: 'binary',
|
|
keyEncoding: 'binary'
|
|
});
|
|
}
|
|
|
|
return stream;
|
|
};
|
|
|
|
/**
|
|
* Will give inputs that spend previous outputs for an address as an object with:
|
|
* address - The base58check encoded address
|
|
* hashtype - The type of the address, e.g. 'pubkeyhash' or 'scripthash'
|
|
* txid - A string of the transaction hash
|
|
* outputIndex - A number of corresponding transaction input
|
|
* height - The height of the block the transaction was included, will be -1 for mempool transactions
|
|
* confirmations - The number of confirmations, will equal 0 for mempool transactions
|
|
*
|
|
* @param {String} addressStr - The relevant address
|
|
* @param {Object} options - Additional options for query the outputs
|
|
* @param {Number} [options.start] - The relevant start block height
|
|
* @param {Number} [options.end] - The relevant end block height
|
|
* @param {Boolean} [options.queryMempool] - Include the mempool in the results
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.getInputs = function(addressStr, options, callback) {
|
|
|
|
var self = this;
|
|
|
|
var inputs = [];
|
|
|
|
var addrObj = encoding.getAddressInfo(addressStr);
|
|
var hashBuffer = addrObj.hashBuffer;
|
|
var hashTypeBuffer = addrObj.hashTypeBuffer;
|
|
|
|
var stream = this.createInputsStream(addressStr, options);
|
|
|
|
stream.on('data', function(input) {
|
|
inputs.push(input);
|
|
if (inputs.length > self.maxInputsQueryLength) {
|
|
log.warn('Tried to query too many inputs (' + self.maxInputsQueryLength + ') for address '+ addressStr);
|
|
error = new Error('Maximum number of inputs (' + self.maxInputsQueryLength + ') per query reached');
|
|
stream.end();
|
|
}
|
|
});
|
|
|
|
var error;
|
|
|
|
stream.on('error', function(streamError) {
|
|
if (streamError) {
|
|
error = streamError;
|
|
}
|
|
});
|
|
|
|
stream.on('finish', function() {
|
|
if (error) {
|
|
return callback(error);
|
|
}
|
|
|
|
if(options.queryMempool) {
|
|
self._getInputsMempool(addressStr, hashBuffer, hashTypeBuffer, function(err, mempoolInputs) {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
inputs = inputs.concat(mempoolInputs);
|
|
callback(null, inputs);
|
|
});
|
|
} else {
|
|
callback(null, inputs);
|
|
}
|
|
|
|
});
|
|
|
|
return stream;
|
|
|
|
};
|
|
|
|
AddressService.prototype._getInputsMempool = function(addressStr, hashBuffer, hashTypeBuffer, callback) {
|
|
var self = this;
|
|
var mempoolInputs = [];
|
|
|
|
var stream = self.mempoolIndex.createReadStream({
|
|
gte: Buffer.concat([
|
|
constants.MEMPREFIXES.SPENTS,
|
|
hashBuffer,
|
|
hashTypeBuffer,
|
|
constants.SPACER_MIN
|
|
]),
|
|
lte: Buffer.concat([
|
|
constants.MEMPREFIXES.SPENTS,
|
|
hashBuffer,
|
|
hashTypeBuffer,
|
|
constants.SPACER_MAX
|
|
]),
|
|
valueEncoding: 'binary',
|
|
keyEncoding: 'binary'
|
|
});
|
|
|
|
stream.on('data', function(data) {
|
|
var txid = data.value.slice(0, 32);
|
|
var inputIndex = data.value.readUInt32BE(32);
|
|
var timestamp = data.value.readDoubleBE(36);
|
|
var input = {
|
|
address: addressStr,
|
|
hashType: constants.HASH_TYPES_READABLE[hashTypeBuffer.toString('hex')],
|
|
txid: txid.toString('hex'), //TODO use a buffer
|
|
inputIndex: inputIndex,
|
|
timestamp: timestamp,
|
|
height: -1,
|
|
confirmations: 0
|
|
};
|
|
mempoolInputs.push(input);
|
|
});
|
|
|
|
var error;
|
|
|
|
stream.on('error', function(streamError) {
|
|
if (streamError) {
|
|
error = streamError;
|
|
}
|
|
});
|
|
|
|
stream.on('close', function() {
|
|
if (error) {
|
|
return callback(error);
|
|
}
|
|
callback(null, mempoolInputs);
|
|
});
|
|
|
|
};
|
|
|
|
AddressService.prototype._getSpentMempool = function(txidBuffer, outputIndex, callback) {
|
|
var outputIndexBuffer = new Buffer(4);
|
|
outputIndexBuffer.writeUInt32BE(outputIndex);
|
|
var spentIndexKey = Buffer.concat([
|
|
constants.MEMPREFIXES.SPENTSMAP,
|
|
txidBuffer,
|
|
outputIndexBuffer
|
|
]);
|
|
|
|
this.mempoolIndex.get(
|
|
spentIndexKey,
|
|
function(err, mempoolValue) {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
var inputTxId = mempoolValue.slice(0, 32);
|
|
var inputIndex = mempoolValue.readUInt32BE(32);
|
|
callback(null, {
|
|
inputTxId: inputTxId.toString('hex'),
|
|
inputIndex: inputIndex
|
|
});
|
|
}
|
|
);
|
|
};
|
|
|
|
AddressService.prototype.createOutputsStream = function(addressStr, options) {
|
|
var outputStream = new OutputsTransformStream({
|
|
address: new Address(addressStr, this.node.network),
|
|
tipHeight: this.node.services.db.tip.__height
|
|
});
|
|
|
|
var stream = this.createOutputsDBStream(addressStr, options)
|
|
.on('error', function(err) {
|
|
// Forward the error
|
|
outputStream.emit('error', err);
|
|
outputStream.end();
|
|
})
|
|
.pipe(outputStream);
|
|
|
|
return stream;
|
|
|
|
};
|
|
|
|
AddressService.prototype.createOutputsDBStream = function(addressStr, options) {
|
|
|
|
var addrObj = encoding.getAddressInfo(addressStr);
|
|
var hashBuffer = addrObj.hashBuffer;
|
|
var hashTypeBuffer = addrObj.hashTypeBuffer;
|
|
var stream;
|
|
|
|
if (options.start >= 0 && options.end >= 0) {
|
|
|
|
var endBuffer = new Buffer(4);
|
|
endBuffer.writeUInt32BE(options.end, 0);
|
|
|
|
var startBuffer = new Buffer(4);
|
|
// Because the key has additional data following it, we don't have an ability
|
|
// to use "gte" or "lte" we can only use "gt" and "lt", we therefore need to adjust the number
|
|
// to be one value larger to include it.
|
|
var startAdjusted = options.start + 1;
|
|
startBuffer.writeUInt32BE(startAdjusted, 0);
|
|
|
|
stream = this.node.services.db.store.createReadStream({
|
|
gt: Buffer.concat([
|
|
constants.PREFIXES.OUTPUTS,
|
|
hashBuffer,
|
|
hashTypeBuffer,
|
|
constants.SPACER_MIN,
|
|
endBuffer
|
|
]),
|
|
lt: Buffer.concat([
|
|
constants.PREFIXES.OUTPUTS,
|
|
hashBuffer,
|
|
hashTypeBuffer,
|
|
constants.SPACER_MIN,
|
|
startBuffer
|
|
]),
|
|
valueEncoding: 'binary',
|
|
keyEncoding: 'binary'
|
|
});
|
|
} else {
|
|
var allKey = Buffer.concat([constants.PREFIXES.OUTPUTS, hashBuffer, hashTypeBuffer]);
|
|
stream = this.node.services.db.store.createReadStream({
|
|
gt: Buffer.concat([allKey, constants.SPACER_HEIGHT_MIN]),
|
|
lt: Buffer.concat([allKey, constants.SPACER_HEIGHT_MAX]),
|
|
valueEncoding: 'binary',
|
|
keyEncoding: 'binary'
|
|
});
|
|
}
|
|
|
|
return stream;
|
|
|
|
};
|
|
|
|
/**
|
|
* Will give outputs for an address as an object with:
|
|
* address - The base58check encoded address
|
|
* hashtype - The type of the address, e.g. 'pubkeyhash' or 'scripthash'
|
|
* txid - A string of the transaction hash
|
|
* outputIndex - A number of corresponding transaction output
|
|
* height - The height of the block the transaction was included, will be -1 for mempool transactions
|
|
* satoshis - The satoshis value of the output
|
|
* script - The script of the output as a hex string
|
|
* confirmations - The number of confirmations, will equal 0 for mempool transactions
|
|
*
|
|
* @param {String} addressStr - The relevant address
|
|
* @param {Object} options - Additional options for query the outputs
|
|
* @param {Number} [options.start] - The relevant start block height
|
|
* @param {Number} [options.end] - The relevant end block height
|
|
* @param {Boolean} [options.queryMempool] - Include the mempool in the results
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.getOutputs = function(addressStr, options, callback) {
|
|
var self = this;
|
|
$.checkArgument(_.isObject(options), 'Second argument is expected to be an options object.');
|
|
$.checkArgument(_.isFunction(callback), 'Third argument is expected to be a callback function.');
|
|
|
|
var addrObj = encoding.getAddressInfo(addressStr);
|
|
var hashBuffer = addrObj.hashBuffer;
|
|
var hashTypeBuffer = addrObj.hashTypeBuffer;
|
|
if (!hashTypeBuffer) {
|
|
return callback(new Error('Unknown address type: ' + addrObj.hashTypeReadable + ' for address: ' + addressStr));
|
|
}
|
|
|
|
var outputs = [];
|
|
var stream = this.createOutputsStream(addressStr, options);
|
|
|
|
stream.on('data', function(data) {
|
|
outputs.push(data);
|
|
if (outputs.length > self.maxOutputsQueryLength) {
|
|
log.warn('Tried to query too many outputs (' + self.maxOutputsQueryLength + ') for address ' + addressStr);
|
|
error = new Error('Maximum number of outputs (' + self.maxOutputsQueryLength + ') per query reached');
|
|
stream.end();
|
|
}
|
|
});
|
|
|
|
var error;
|
|
|
|
stream.on('error', function(streamError) {
|
|
if (streamError) {
|
|
error = streamError;
|
|
}
|
|
});
|
|
|
|
stream.on('finish', function() {
|
|
if (error) {
|
|
return callback(error);
|
|
}
|
|
|
|
if(options.queryMempool) {
|
|
self._getOutputsMempool(addressStr, hashBuffer, hashTypeBuffer, function(err, mempoolOutputs) {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
outputs = outputs.concat(mempoolOutputs);
|
|
callback(null, outputs);
|
|
});
|
|
} else {
|
|
callback(null, outputs);
|
|
}
|
|
});
|
|
|
|
return stream;
|
|
|
|
};
|
|
|
|
AddressService.prototype._getOutputsMempool = function(addressStr, hashBuffer, hashTypeBuffer, callback) {
|
|
var self = this;
|
|
var mempoolOutputs = [];
|
|
|
|
var stream = self.mempoolIndex.createReadStream({
|
|
gte: Buffer.concat([
|
|
constants.MEMPREFIXES.OUTPUTS,
|
|
hashBuffer,
|
|
hashTypeBuffer,
|
|
constants.SPACER_MIN
|
|
]),
|
|
lte: Buffer.concat([
|
|
constants.MEMPREFIXES.OUTPUTS,
|
|
hashBuffer,
|
|
hashTypeBuffer,
|
|
constants.SPACER_MAX
|
|
]),
|
|
valueEncoding: 'binary',
|
|
keyEncoding: 'binary'
|
|
});
|
|
|
|
stream.on('data', function(data) {
|
|
// Format of data:
|
|
// prefix: 1, hashBuffer: 20, hashTypeBuffer: 1, txid: 32, outputIndex: 4
|
|
var txid = data.key.slice(22, 54);
|
|
var outputIndex = data.key.readUInt32BE(54);
|
|
var value = encoding.decodeOutputMempoolValue(data.value);
|
|
var output = {
|
|
address: addressStr,
|
|
hashType: constants.HASH_TYPES_READABLE[hashTypeBuffer.toString('hex')],
|
|
txid: txid.toString('hex'), //TODO use a buffer
|
|
outputIndex: outputIndex,
|
|
height: -1,
|
|
timestamp: value.timestamp,
|
|
satoshis: value.satoshis,
|
|
script: value.scriptBuffer.toString('hex'), //TODO use a buffer
|
|
confirmations: 0
|
|
};
|
|
mempoolOutputs.push(output);
|
|
});
|
|
|
|
var error;
|
|
|
|
stream.on('error', function(streamError) {
|
|
if (streamError) {
|
|
error = streamError;
|
|
}
|
|
});
|
|
|
|
stream.on('close', function() {
|
|
if (error) {
|
|
return callback(error);
|
|
}
|
|
callback(null, mempoolOutputs);
|
|
});
|
|
|
|
};
|
|
|
|
/**
|
|
* Will give unspent outputs for an address or an array of addresses.
|
|
* @param {Array|String} addresses - An array of addresses
|
|
* @param {Boolean} queryMempool - Include or exclude the mempool
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.getUnspentOutputs = function(addresses, queryMempool, callback) {
|
|
var self = this;
|
|
|
|
if(!Array.isArray(addresses)) {
|
|
addresses = [addresses];
|
|
}
|
|
|
|
var utxos = [];
|
|
|
|
async.eachSeries(addresses, function(address, next) {
|
|
self.getUnspentOutputsForAddress(address, queryMempool, function(err, unspents) {
|
|
if(err && err instanceof errors.NoOutputs) {
|
|
return next();
|
|
} else if(err) {
|
|
return next(err);
|
|
}
|
|
|
|
utxos = utxos.concat(unspents);
|
|
next();
|
|
});
|
|
}, function(err) {
|
|
callback(err, utxos);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Will give unspent outputs for an address.
|
|
* @param {String} address - An address in base58check encoding
|
|
* @param {Boolean} queryMempool - Include or exclude the mempool
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.getUnspentOutputsForAddress = function(address, queryMempool, callback) {
|
|
|
|
var self = this;
|
|
|
|
this.getOutputs(address, {queryMempool: queryMempool}, function(err, outputs) {
|
|
if (err) {
|
|
return callback(err);
|
|
} else if(!outputs.length) {
|
|
return callback(new errors.NoOutputs('Address ' + address + ' has no outputs'), []);
|
|
}
|
|
|
|
var opts = {
|
|
queryMempool: queryMempool
|
|
};
|
|
|
|
var isUnspent = function(output, callback) {
|
|
self.isUnspent(output, opts, callback);
|
|
};
|
|
|
|
async.filter(outputs, isUnspent, function(results) {
|
|
callback(null, results);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Will give the inverse of isSpent
|
|
* @param {Object} output
|
|
* @param {Object} options
|
|
* @param {Boolean} options.queryMempool - Include mempool in results
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.isUnspent = function(output, options, callback) {
|
|
$.checkArgument(_.isFunction(callback));
|
|
this.isSpent(output, options, function(spent) {
|
|
callback(!spent);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Will determine if an output is spent.
|
|
* @param {Object} output - An output as returned from getOutputs
|
|
* @param {Object} options
|
|
* @param {Boolean} options.queryMempool - Include mempool in results
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.isSpent = function(output, options, callback) {
|
|
$.checkArgument(_.isFunction(callback));
|
|
var queryMempool = _.isUndefined(options.queryMempool) ? true : options.queryMempool;
|
|
var self = this;
|
|
var txid = output.prevTxId ? output.prevTxId.toString('hex') : output.txid;
|
|
var spent = self.node.services.bitcoind.isSpent(txid, output.outputIndex);
|
|
if (!spent && queryMempool) {
|
|
var txidBuffer = new Buffer(txid, 'hex');
|
|
var spentIndexSyncKey = encoding.encodeSpentIndexSyncKey(txidBuffer, output.outputIndex);
|
|
spent = self.mempoolSpentIndex[spentIndexSyncKey] ? true : false;
|
|
}
|
|
setImmediate(function() {
|
|
// TODO error should be the first argument?
|
|
callback(spent);
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* This will give the history for many addresses limited by a range of block heights (to limit
|
|
* the database lookup times) and/or paginated to limit the results length.
|
|
*
|
|
* The response format will be:
|
|
* {
|
|
* totalCount: 12 // the total number of items there are between the two heights
|
|
* items: [
|
|
* {
|
|
* addresses: {
|
|
* '12c6DSiU4Rq3P4ZxziKxzrL5LmMBrzjrJX': {
|
|
* inputIndexes: [],
|
|
* outputIndexes: [0]
|
|
* }
|
|
* },
|
|
* satoshis: 100,
|
|
* height: 300000,
|
|
* confirmations: 1,
|
|
* timestamp: 1442337090 // in seconds
|
|
* fees: 1000 // in satoshis
|
|
* tx: <Transaction>
|
|
* }
|
|
* ]
|
|
* }
|
|
* @param {Array} addresses - An array of addresses
|
|
* @param {Object} options - The options to limit the query
|
|
* @param {Number} [options.from] - The pagination "from" index
|
|
* @param {Number} [options.to] - The pagination "to" index
|
|
* @param {Number} [options.start] - The beginning block height (e.g. 1500 the most recent block height).
|
|
* @param {Number} [options.end] - The ending block height (e.g. 0 the older block height, results are inclusive).
|
|
* @param {Boolean} [options.queryMempool] - Include the mempool in the query
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.getAddressHistory = function(addresses, options, callback) {
|
|
var history = new AddressHistory({
|
|
node: this.node,
|
|
options: options,
|
|
addresses: addresses
|
|
});
|
|
history.get(callback);
|
|
};
|
|
|
|
/**
|
|
* This will give an object with:
|
|
* balance - confirmed balance
|
|
* unconfirmedBalance - unconfirmed balance
|
|
* totalReceived - satoshis received
|
|
* totalSpent - satoshis spent
|
|
* appearances - number of transactions
|
|
* unconfirmedAppearances - number of unconfirmed transactions
|
|
* txids - list of txids (unless noTxList is set)
|
|
*
|
|
* @param {String} address
|
|
* @param {Object} options
|
|
* @param {Boolean} [options.noTxList] - if set, txid array will not be included
|
|
* @param {Function} callback
|
|
*/
|
|
AddressService.prototype.getAddressSummary = function(addressArg, options, callback) {
|
|
var self = this;
|
|
|
|
var startTime = new Date();
|
|
var address = new Address(addressArg);
|
|
|
|
if (_.isUndefined(options.queryMempool)) {
|
|
options.queryMempool = true;
|
|
}
|
|
|
|
async.waterfall([
|
|
function(next) {
|
|
self._getAddressConfirmedSummary(address, options, next);
|
|
},
|
|
function(result, next) {
|
|
self._getAddressMempoolSummary(address, options, result, next);
|
|
},
|
|
function(result, next) {
|
|
self._setAndSortTxidsFromAppearanceIds(result, next);
|
|
}
|
|
], function(err, result) {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
|
|
var summary = self._transformAddressSummaryFromResult(result, options);
|
|
|
|
var timeDelta = new Date() - startTime;
|
|
if (timeDelta > 5000) {
|
|
var seconds = Math.round(timeDelta / 1000);
|
|
log.warn('Slow (' + seconds + 's) getAddressSummary request for address: ' + address.toString());
|
|
}
|
|
|
|
callback(null, summary);
|
|
|
|
});
|
|
|
|
};
|
|
|
|
AddressService.prototype._getAddressConfirmedSummary = function(address, options, callback) {
|
|
var self = this;
|
|
var baseResult = {
|
|
appearanceIds: {},
|
|
totalReceived: 0,
|
|
balance: 0,
|
|
unconfirmedAppearanceIds: {},
|
|
unconfirmedBalance: 0
|
|
};
|
|
|
|
async.waterfall([
|
|
function(next) {
|
|
self._getAddressConfirmedInputsSummary(address, baseResult, options, next);
|
|
},
|
|
function(result, next) {
|
|
self._getAddressConfirmedOutputsSummary(address, result, options, next);
|
|
}
|
|
], callback);
|
|
|
|
};
|
|
|
|
AddressService.prototype._getAddressConfirmedInputsSummary = function(address, result, options, callback) {
|
|
$.checkArgument(address instanceof Address);
|
|
var self = this;
|
|
var error = null;
|
|
var count = 0;
|
|
|
|
var inputsStream = self.createInputsStream(address, options);
|
|
inputsStream.on('data', function(input) {
|
|
var txid = input.txid;
|
|
result.appearanceIds[txid] = input.height;
|
|
|
|
count++;
|
|
|
|
if (count > self.maxInputsQueryLength) {
|
|
log.warn('Tried to query too many inputs (' + self.maxInputsQueryLength + ') for summary of address ' + address.toString());
|
|
error = new Error('Maximum number of inputs (' + self.maxInputsQueryLength + ') per query reached');
|
|
inputsStream.end();
|
|
}
|
|
|
|
});
|
|
|
|
inputsStream.on('error', function(err) {
|
|
error = err;
|
|
});
|
|
|
|
inputsStream.on('end', function() {
|
|
if (error) {
|
|
return callback(error);
|
|
}
|
|
callback(null, result);
|
|
});
|
|
};
|
|
|
|
AddressService.prototype._getAddressConfirmedOutputsSummary = function(address, result, options, callback) {
|
|
$.checkArgument(address instanceof Address);
|
|
$.checkArgument(!_.isUndefined(result) &&
|
|
!_.isUndefined(result.appearanceIds) &&
|
|
!_.isUndefined(result.unconfirmedAppearanceIds));
|
|
|
|
var self = this;
|
|
var count = 0;
|
|
|
|
var outputStream = self.createOutputsStream(address, options);
|
|
|
|
outputStream.on('data', function(output) {
|
|
|
|
var txid = output.txid;
|
|
var outputIndex = output.outputIndex;
|
|
result.totalReceived += output.satoshis;
|
|
result.appearanceIds[txid] = output.height;
|
|
|
|
if(!options.noBalance) {
|
|
|
|
// Bitcoind's isSpent only works for confirmed transactions
|
|
var spentDB = self.node.services.bitcoind.isSpent(txid, outputIndex);
|
|
|
|
if(!spentDB) {
|
|
result.balance += output.satoshis;
|
|
}
|
|
|
|
if(options.queryMempool) {
|
|
// Check to see if this output is spent in the mempool and if so
|
|
// we will subtract it from the unconfirmedBalance (a.k.a unconfirmedDelta)
|
|
var spentIndexSyncKey = encoding.encodeSpentIndexSyncKey(
|
|
new Buffer(txid, 'hex'), // TODO: get buffer directly
|
|
outputIndex
|
|
);
|
|
var spentMempool = self.mempoolSpentIndex[spentIndexSyncKey];
|
|
if(spentMempool) {
|
|
result.unconfirmedBalance -= output.satoshis;
|
|
}
|
|
}
|
|
}
|
|
|
|
count++;
|
|
|
|
if (count > self.maxOutputsQueryLength) {
|
|
log.warn('Tried to query too many outputs (' + self.maxOutputsQueryLength + ') for summary of address ' + address.toString());
|
|
error = new Error('Maximum number of outputs (' + self.maxOutputsQueryLength + ') per query reached');
|
|
outputStream.end();
|
|
}
|
|
|
|
});
|
|
|
|
var error = null;
|
|
|
|
outputStream.on('error', function(err) {
|
|
error = err;
|
|
});
|
|
|
|
outputStream.on('end', function() {
|
|
if (error) {
|
|
return callback(error);
|
|
}
|
|
callback(null, result);
|
|
});
|
|
|
|
};
|
|
|
|
AddressService.prototype._setAndSortTxidsFromAppearanceIds = function(result, callback) {
|
|
result.txids = Object.keys(result.appearanceIds);
|
|
result.txids.sort(function(a, b) {
|
|
return result.appearanceIds[a] - result.appearanceIds[b];
|
|
});
|
|
result.unconfirmedTxids = Object.keys(result.unconfirmedAppearanceIds);
|
|
result.unconfirmedTxids.sort(function(a, b) {
|
|
return result.unconfirmedAppearanceIds[a] - result.unconfirmedAppearanceIds[b];
|
|
});
|
|
callback(null, result);
|
|
};
|
|
|
|
AddressService.prototype._getAddressMempoolSummary = function(address, options, result, callback) {
|
|
var self = this;
|
|
|
|
// Skip if the options do not want to include the mempool
|
|
if (!options.queryMempool) {
|
|
return callback(null, result);
|
|
}
|
|
|
|
var addressStr = address.toString();
|
|
var hashBuffer = address.hashBuffer;
|
|
var hashTypeBuffer = constants.HASH_TYPES_MAP[address.type];
|
|
var addressIndexKey = encoding.encodeMempoolAddressIndexKey(hashBuffer, hashTypeBuffer);
|
|
|
|
if(!this.mempoolAddressIndex[addressIndexKey]) {
|
|
return callback(null, result);
|
|
}
|
|
|
|
async.waterfall([
|
|
function(next) {
|
|
self._getInputsMempool(addressStr, hashBuffer, hashTypeBuffer, function(err, mempoolInputs) {
|
|
if (err) {
|
|
return next(err);
|
|
}
|
|
for(var i = 0; i < mempoolInputs.length; i++) {
|
|
var input = mempoolInputs[i];
|
|
result.unconfirmedAppearanceIds[input.txid] = input.timestamp;
|
|
}
|
|
next(null, result);
|
|
});
|
|
|
|
}, function(result, next) {
|
|
self._getOutputsMempool(addressStr, hashBuffer, hashTypeBuffer, function(err, mempoolOutputs) {
|
|
if (err) {
|
|
return next(err);
|
|
}
|
|
for(var i = 0; i < mempoolOutputs.length; i++) {
|
|
var output = mempoolOutputs[i];
|
|
|
|
result.unconfirmedAppearanceIds[output.txid] = output.timestamp;
|
|
|
|
if(!options.noBalance) {
|
|
var spentIndexSyncKey = encoding.encodeSpentIndexSyncKey(
|
|
new Buffer(output.txid, 'hex'), // TODO: get buffer directly
|
|
output.outputIndex
|
|
);
|
|
var spentMempool = self.mempoolSpentIndex[spentIndexSyncKey];
|
|
// Only add this to the balance if it's not spent in the mempool already
|
|
if(!spentMempool) {
|
|
result.unconfirmedBalance += output.satoshis;
|
|
}
|
|
}
|
|
}
|
|
next(null, result);
|
|
});
|
|
}
|
|
], callback);
|
|
};
|
|
|
|
AddressService.prototype._transformAddressSummaryFromResult = function(result, options) {
|
|
|
|
var confirmedTxids = result.txids;
|
|
var unconfirmedTxids = result.unconfirmedTxids;
|
|
|
|
var summary = {
|
|
totalReceived: result.totalReceived,
|
|
totalSpent: result.totalReceived - result.balance,
|
|
balance: result.balance,
|
|
appearances: confirmedTxids.length,
|
|
unconfirmedBalance: result.unconfirmedBalance,
|
|
unconfirmedAppearances: unconfirmedTxids.length
|
|
};
|
|
|
|
if (options.fullTxList) {
|
|
summary.appearanceIds = result.appearanceIds;
|
|
summary.unconfirmedAppearanceIds = result.unconfirmedAppearanceIds;
|
|
} else if (!options.noTxList) {
|
|
summary.txids = confirmedTxids.concat(unconfirmedTxids);
|
|
}
|
|
|
|
return summary;
|
|
|
|
};
|
|
|
|
module.exports = AddressService;
|