1158 lines
28 KiB
JavaScript
1158 lines
28 KiB
JavaScript
'use strict';
|
|
|
|
var async = require('async');
|
|
var assert = require('assert');
|
|
var BaseService = require('../../service');
|
|
var inherits = require('util').inherits;
|
|
var index = require('../../');
|
|
var log = index.log;
|
|
var multer = require('multer');
|
|
var storage = multer.memoryStorage();
|
|
var upload = multer({ storage: storage });
|
|
var validators = require('./validators');
|
|
var mainUtils = require('../../utils');
|
|
var utils = require('./utils');
|
|
var _ = require('lodash');
|
|
var bodyParser = require('body-parser');
|
|
var LRU = require('lru-cache');
|
|
var Encoding = require('./encoding');
|
|
var bitcore = require('bitcore-lib');
|
|
var Input = bitcore.Transaction.Input;
|
|
var Unit = bitcore.Unit;
|
|
var Transform = require('stream').Transform;
|
|
|
|
var WalletService = function(options) {
|
|
BaseService.call(this, options);
|
|
|
|
this._MAX_QUEUE = 20;
|
|
this._jobs = LRU({
|
|
max: this._MAX_QUEUE,
|
|
maxAge: 86400000 * 3 //3 days
|
|
});
|
|
|
|
this._addressMap = {};
|
|
this.balances = {};
|
|
|
|
this.db = this.node.services.db;
|
|
};
|
|
|
|
inherits(WalletService, BaseService);
|
|
|
|
WalletService.dependencies = [
|
|
'web',
|
|
'address',
|
|
'transaction',
|
|
'timestamp'
|
|
];
|
|
|
|
WalletService.prototype.getAPIMethods = function() {
|
|
return [];
|
|
};
|
|
|
|
WalletService.prototype.start = function(callback) {
|
|
var self = this;
|
|
|
|
|
|
self.node.services.db.getPrefix(self.name, function(err, servicePrefix) {
|
|
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
self.servicePrefix = servicePrefix;
|
|
self._encoding = new Encoding(self.servicePrefix);
|
|
|
|
self._loadAllAddresses(function(err) {
|
|
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
self.setListeners();
|
|
self._loadAllBalances(callback);
|
|
});
|
|
|
|
});
|
|
};
|
|
|
|
WalletService.prototype._setListeners = function() {
|
|
this._startSubscriptions();
|
|
};
|
|
|
|
WalletService.prototype._startSubscriptions = function() {
|
|
|
|
var self = this;
|
|
|
|
if (self._subscribed) {
|
|
return;
|
|
}
|
|
|
|
self._subscribed = true;
|
|
self.bus = self.node.openBus({remoteAddress: 'localhost'});
|
|
|
|
self.bus.on('block/block', self._onBlock.bind(self));
|
|
self.bus.subscribe('block/block');
|
|
};
|
|
|
|
WalletService.prototype._onBlock = function(block) {
|
|
};
|
|
|
|
WalletService.prototype.stop = function(callback) {
|
|
setImmediate(callback);
|
|
};
|
|
|
|
WalletService.prototype.getPublishEvents = function() {
|
|
return [];
|
|
};
|
|
|
|
|
|
WalletService.prototype.getAddressString = function(io) {
|
|
|
|
var address = io.script.toAddress(this.node.network);
|
|
|
|
if(address) {
|
|
return address.toString();
|
|
}
|
|
|
|
try {
|
|
var pubkey = io.script.getPublicKey();
|
|
if(pubkey) {
|
|
return pubkey.toString('hex');
|
|
}
|
|
} catch(e) {}
|
|
|
|
};
|
|
|
|
WalletService.prototype._checkAddresses = function() {
|
|
return Object.keys(this._addressMap).length > 0;
|
|
};
|
|
|
|
var self = this;
|
|
|
|
self._addressMap = {};
|
|
|
|
var start = self._encoding.encodeWalletAddressesKey('00');
|
|
var end = self._encoding.encodeWalletAddressesKey(Array(65).join('f'));
|
|
|
|
var stream = self.db.createReadStream({
|
|
gte: start,
|
|
lt: end
|
|
});
|
|
|
|
var streamErr = null;
|
|
|
|
stream.on('data', function(data) {
|
|
var key = self._encoding.decodeWalletAddressesKey(data.key);
|
|
var value = self._encoding.decodeWalletAddressesValue(data.value);
|
|
value.forEach(function(address) {
|
|
if(!self._addressMap[address]) {
|
|
self._addressMap[address] = [];
|
|
}
|
|
|
|
self._addressMap[address].push(key);
|
|
});
|
|
});
|
|
|
|
stream.on('error', function(err) {
|
|
streamErr = err;
|
|
});
|
|
|
|
stream.on('end', function() {
|
|
callback(streamErr);
|
|
});
|
|
};
|
|
|
|
WalletService.prototype._loadAllBalances = function(callback) {
|
|
var self = this;
|
|
|
|
self._balances = {};
|
|
|
|
var start = self._encoding.encodeWalletBalanceKey('00');
|
|
var end = self._encoding.encodeWalletBalanceKey(Array(65).join('f'));
|
|
|
|
var stream = self.db.createReadStream({
|
|
gte: start,
|
|
lt: end
|
|
});
|
|
|
|
var streamErr = null;
|
|
|
|
stream.on('data', function(data) {
|
|
var walletId = self._encoding.decodeWalletBalanceKey(data.key);
|
|
var balance = self._encoding.decodeWalletBalanceValue(data.value);
|
|
|
|
self._balances[walletId] = balance;
|
|
});
|
|
|
|
stream.on('error', function(err) {
|
|
streamErr = err;
|
|
});
|
|
|
|
stream.on('end', function() {
|
|
callback(streamErr);
|
|
});
|
|
};
|
|
|
|
|
|
WalletService.prototype._endpointUTXOs = function() {
|
|
var self = this;
|
|
return function(req, res) {
|
|
req.setTimeout(600000);
|
|
var walletId = req.params.walletId;
|
|
var queryMempool = req.query.queryMempool !== false;
|
|
var height = self.node.services.db.tip.__height;
|
|
var options = {
|
|
queryMempool: queryMempool
|
|
};
|
|
self.db.pauseSync(function() {
|
|
self._getUtxos(walletId, options, function(err, utxos) {
|
|
if(err) {
|
|
return utils.sendError(err, res);
|
|
}
|
|
self.db.resumeSync();
|
|
res.status(200).jsonp({
|
|
utxos: utxos,
|
|
height: height
|
|
});
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._endpointGetBalance= function() {
|
|
var self = this;
|
|
return function(req, res) {
|
|
req.setTimeout(600000);
|
|
var walletId = req.params.walletId;
|
|
var queryMempool = req.query.queryMempool !== false;
|
|
var byAddress = req.query.byAddress;
|
|
|
|
var options = {
|
|
queryMempool: queryMempool,
|
|
byAddress: byAddress
|
|
};
|
|
|
|
self.db.pauseSync(function() {
|
|
self._getBalance(walletId, options, function(err, result) {
|
|
if(err) {
|
|
return utils.sendError(err, res);
|
|
}
|
|
self.db.resumeSync();
|
|
res.status(200).jsonp({
|
|
satoshis: result,
|
|
height: self.node.services.db.tip.__height,
|
|
hash: self.node.services.db.tip.hash
|
|
});
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._endpointRemoveWallet = function() {
|
|
var self = this;
|
|
return function(req, res) {
|
|
var walletId = req.params.walletId;
|
|
|
|
self.db.pauseSync(function() {
|
|
self._removeWallet(walletId, function(err, numRecords) {
|
|
if(err) {
|
|
return utils.sendError(err, res);
|
|
}
|
|
self.db.resumeSync();
|
|
res.status(200).jsonp({
|
|
walletId: walletId,
|
|
numberRemoved: numRecords
|
|
});
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._endpointRemoveAllWallets = function() {
|
|
var self = this;
|
|
return function(req, res) {
|
|
|
|
self.db.pauseSync(function() {
|
|
self._removeAllWallets(function(err, numRecords) {
|
|
if(err) {
|
|
return utils.sendError(err, res);
|
|
}
|
|
self.db.resumeSync();
|
|
res.status(200).jsonp({
|
|
numberRemoved: numRecords
|
|
});
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._endpointGetAddresses = function() {
|
|
var self = this;
|
|
return function(req, res) {
|
|
var walletId = req.params.walletId;
|
|
|
|
self.db.pauseSync(function() {
|
|
self._getAddresses(walletId, function(err, addresses) {
|
|
self.db.resumeSync();
|
|
if(err) {
|
|
return utils.sendError(err, res);
|
|
}
|
|
|
|
if(!addresses) {
|
|
return res.status(404).send('Not found');
|
|
}
|
|
|
|
res.status(200).jsonp({
|
|
addresses: addresses.length
|
|
});
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._endpointDumpAllWallets = function() {
|
|
var self = this;
|
|
return function(req, res) {
|
|
var keys = [];
|
|
|
|
var start = new Buffer(self.servicePrefix);
|
|
var end = new Buffer.concat([start, new Buffer('ff', 'hex')]);
|
|
|
|
var stream = self.db.createKeyStream({
|
|
gte: start,
|
|
lt: end
|
|
});
|
|
|
|
var streamErr = null;
|
|
stream.on('error', function(err) {
|
|
streamErr = err;
|
|
});
|
|
|
|
stream.on('data', function(data) {
|
|
keys.push(data);
|
|
});
|
|
|
|
stream.on('end', function() {
|
|
if(streamErr) {
|
|
return utils.sendError(streamErr, res);
|
|
}
|
|
var resultsMap = keys.map(function(key) {
|
|
return key.toString('hex');
|
|
});
|
|
res.status(200).jsonp({
|
|
result: resultsMap
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._endpointGetWalletIds = function() {
|
|
var self = this;
|
|
return function(req, res) {
|
|
var start = new Buffer.concat([self.servicePrefix, new Buffer(self._encoding.subKeyMap.addresses.buffer)]);
|
|
var end = new Buffer.concat([start, new Buffer('ff', 'hex')]);
|
|
var stream = self.db.createKeyStream({
|
|
gte: start,
|
|
lt: end
|
|
});
|
|
var walletIds = [];
|
|
|
|
var streamErr;
|
|
stream.on('error', function(err) {
|
|
streamErr = err;
|
|
});
|
|
|
|
stream.on('data', function(data) {
|
|
walletIds.push(self._encoding.decodeWalletAddressesKey(data));
|
|
});
|
|
|
|
stream.on('end', function() {
|
|
if(streamErr) {
|
|
return utils.sendError(streamErr, res);
|
|
}
|
|
res.status(200).jsonp({
|
|
walletIds: walletIds
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._endpointRegisterWallet = function() {
|
|
var self = this;
|
|
return function(req, res) {
|
|
var walletId = req.params.walletId;
|
|
if (!walletId) {
|
|
walletId = utils.getWalletId();
|
|
}
|
|
self._createWallet(walletId, function(err) {
|
|
if(err) {
|
|
return utils.sendError(err, res);
|
|
}
|
|
res.status(201).jsonp({
|
|
walletId: walletId
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._endpointResyncAddresses = function() {
|
|
|
|
var self = this;
|
|
|
|
return function(req, res) {
|
|
var walletId = req.params.walletId;
|
|
|
|
|
|
if (!walletId) {
|
|
return utils.sendError(new Error('WalletId must be given.'), res);
|
|
}
|
|
|
|
if (!self._isJobQueueReady()) {
|
|
return utils.sendError(new Error('Job queue is currently overloaded, please try again later.'), res);
|
|
}
|
|
|
|
self.db.pauseSync(function() {
|
|
|
|
self._getAddresses(walletId, function(err, oldAddresses) {
|
|
|
|
if(err) {
|
|
return utils.sendError(err, res);
|
|
}
|
|
|
|
if(!oldAddresses) {
|
|
return res.status(404).send('Not found');
|
|
}
|
|
|
|
self._removeWallet(walletId, function(err) {
|
|
|
|
if(err) {
|
|
return utils.sendError(err, res);
|
|
}
|
|
|
|
self._createWallet(walletId, function() {
|
|
|
|
var jobId = utils.generateJobId();
|
|
self._importAddresses(walletId, oldAddresses, jobId, self._jobCompletionCallback.bind(self));
|
|
res.status(200).jsonp({jobId: jobId});
|
|
|
|
});
|
|
});
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._endpointPostAddresses = function() {
|
|
var self = this;
|
|
return function(req, res) {
|
|
|
|
var addresses = req.addresses;
|
|
if (!addresses || !addresses.length) {
|
|
return utils.sendError(new Error('addresses are required when creating a wallet.'), res);
|
|
}
|
|
var walletId = req.params.walletId;
|
|
if (!walletId) {
|
|
return utils.sendError(new Error('WalletId must be given.'), res);
|
|
}
|
|
if (!self._isJobQueueReady()) {
|
|
return utils.sendError(new Error('Job queue is currently overloaded, please try again later.'), res);
|
|
}
|
|
|
|
var jobId = utils.generateJobId();
|
|
|
|
self.db.pauseSync(function() {
|
|
|
|
self._importAddresses(walletId, addresses, jobId, self._jobCompletionCallback.bind(self));
|
|
res.status(200).jsonp({jobId: jobId});
|
|
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._endpointGetTransactions = function() {
|
|
|
|
var self = this;
|
|
|
|
return function(req, res) {
|
|
|
|
var walletId = req.params.walletId;
|
|
|
|
self.db.pauseSync(function() {
|
|
self._processStartEndOptions(req, function(err, heights) {
|
|
|
|
if(err) {
|
|
return utils.sendError(err, res);
|
|
}
|
|
|
|
var options = {
|
|
start: heights[0] || 0,
|
|
end : heights[1] || 0xffffffff,
|
|
self: self,
|
|
walletId: walletId
|
|
};
|
|
|
|
var missingTxidCount = 0;
|
|
var transform = new Transform({ objectMode: true, highWaterMark: 1000000 });
|
|
//txids are sent in and the actual tx's are found here
|
|
transform._transform = function(chunk, enc, callback) {
|
|
|
|
var txid = self._encoding.decodeWalletTransactionKey(chunk).txid.toString('hex');
|
|
|
|
if (txid.length !== 64 || txid === '0000000000000000000000000000000000000000000000000000000000000000') {
|
|
missingTxidCount++;
|
|
log.error('missingTxidCount: ', missingTxidCount);
|
|
return callback();
|
|
}
|
|
|
|
self._getTransactionFromDb(options, txid, function(err, tx) {
|
|
|
|
if(err) {
|
|
log.error(err);
|
|
transform.unpipe();
|
|
return callback();
|
|
}
|
|
|
|
var formattedTx = utils.toJSONL(self._formatTransaction(tx));
|
|
transform.push(formattedTx);
|
|
callback();
|
|
|
|
});
|
|
|
|
};
|
|
|
|
transform._flush = function(callback) {
|
|
self.db.resumeSync();
|
|
callback();
|
|
};
|
|
|
|
var encodingFn = self._encoding.encodeWalletTransactionKey.bind(self._encoding);
|
|
var stream = self.db.createKeyStream(self._getSearchParams(encodingFn, options));
|
|
|
|
stream.on('close', function() {
|
|
stream.unpipe();
|
|
});
|
|
|
|
stream.pipe(transform).pipe(res);
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._formatTransactions = function(txs) {
|
|
return txs.forEach(this._formatTransaction);
|
|
};
|
|
|
|
WalletService.prototype._formatTransaction = function(tx) {
|
|
var obj = tx.toObject();
|
|
|
|
for(var i = 0; i < tx.inputs.length; i++) {
|
|
obj.inputs[i].inputSatoshis = tx.__inputValues[i];
|
|
}
|
|
obj.height = tx.__height;
|
|
obj.timestamp = tx.__timestamp;
|
|
return obj;
|
|
};
|
|
|
|
WalletService.prototype._endpointPutAddresses = function() {
|
|
var self = this;
|
|
return function(req, res) {
|
|
if (!self._isJobQueueReady()) {
|
|
return utils.sendError(new Error('Job Queue is full, current job limit: ' + self._MAX_QUEUE), res);
|
|
}
|
|
|
|
var newAddresses = req.body;
|
|
|
|
if(!Array.isArray(req.body)) {
|
|
return utils.sendError(new Error('Must PUT an array'), res);
|
|
}
|
|
|
|
var walletId = req.params.walletId;
|
|
if (!walletId) {
|
|
return utils.sendError(new Error('WalletId must be given.'), res);
|
|
}
|
|
|
|
self.db.pauseSync(function() {
|
|
|
|
self._getAddresses(walletId, function(err, oldAddresses) {
|
|
|
|
if(err) {
|
|
return utils.sendError(err, res);
|
|
}
|
|
|
|
if(!oldAddresses) {
|
|
return res.status(404).send('Not found');
|
|
}
|
|
|
|
var addAddresses = _.without(newAddresses, oldAddresses);
|
|
|
|
var jobId = utils.generateJobId();
|
|
self._importAddresses(walletId, addAddresses, jobId, self._jobCompletionCallback.bind(self));
|
|
res.status(200).jsonp({jobId: jobId});
|
|
|
|
});
|
|
});
|
|
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._getUtxos = function(walletId, options, callback) {
|
|
var self = this;
|
|
|
|
var stream = self.db.createReadStream({
|
|
gte: self._encoding.encodeWalletUtxoKey(walletId),
|
|
lt: self._encoding.encodeWalletUtxoKey(mainUtils.getTerminalKey(new Buffer(walletId)))
|
|
});
|
|
|
|
var utxos = [];
|
|
var streamErr = null;
|
|
|
|
stream.on('data', function(data) {
|
|
var key = self._encoding.decodeWalletUtxoKey(data.key);
|
|
var value = self._encoding.decodeWalletUtxoValue(data.value);
|
|
utxos.push({
|
|
txid: key.txid,
|
|
vout: key.outputIndex,
|
|
height: value.height,
|
|
satoshis: value.satoshis,
|
|
scriptPubKey: value.script.toString('hex')
|
|
});
|
|
});
|
|
|
|
stream.on('error', function(err) {
|
|
streamErr = err;
|
|
});
|
|
|
|
stream.on('end', function() {
|
|
callback(streamErr, utxos);
|
|
});
|
|
};
|
|
|
|
WalletService.prototype._getBalance = function(walletId, options, callback) {
|
|
|
|
var self = this;
|
|
|
|
var key = self._encoding.encodeWalletBalanceKey(walletId);
|
|
|
|
self.db.get(key, function(err, buffer) {
|
|
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
callback(null, self._encoding.decodeWalletBalanceValue(buffer));
|
|
});
|
|
|
|
};
|
|
|
|
WalletService.prototype._getSearchParams = function(fn, options) {
|
|
return {
|
|
gte: fn.call(this, options.walletId, options.start),
|
|
lt: Buffer.concat([ fn.call(this, options.walletId, options.end).slice(0, -32), new Buffer('ff', 'hex') ])
|
|
};
|
|
};
|
|
|
|
WalletService.prototype._getTransactionFromDb = function(options, txid, callback) {
|
|
|
|
var self = options.self;
|
|
|
|
self.node.services.transaction.getTransaction(txid.toString('hex'), options, function(err, tx) {
|
|
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
if (tx.__inputValues) {
|
|
return callback(null, tx);
|
|
}
|
|
|
|
async.mapLimit(tx.inputs, 8, function(input, next) {
|
|
|
|
self.node.services.transaction.getTransaction(input.prevTxId.toString('hex'), options, function(err, tx) {
|
|
|
|
if(err) {
|
|
return next(err);
|
|
}
|
|
|
|
next(null, tx.outputs[input.outputIndex].satoshis);
|
|
});
|
|
|
|
}, function(err, inputValues) {
|
|
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
tx.__inputValues = inputValues;
|
|
callback(null, tx);
|
|
|
|
});
|
|
});
|
|
|
|
};
|
|
|
|
WalletService.prototype._removeWallet = function(walletId, callback) {
|
|
|
|
var self = this;
|
|
async.map(Object.keys(self._encoding.subKeyMap), function(prefix, next) {
|
|
|
|
var keys = [];
|
|
|
|
var start = self._encoding.subKeyMap[prefix].fn.call(self._encoding, walletId);
|
|
var end = new Buffer.concat([
|
|
self._encoding.subKeyMap[prefix]
|
|
.fn.call(self._encoding, walletId),
|
|
new Buffer('ff', 'hex')]);
|
|
|
|
var stream = self.db.createKeyStream({
|
|
gte: start,
|
|
lt: end
|
|
});
|
|
|
|
var streamErr = null;
|
|
stream.on('error', function(err) {
|
|
streamErr = err;
|
|
});
|
|
|
|
stream.on('data', function(data) {
|
|
keys.push(data);
|
|
});
|
|
|
|
stream.on('end', function() {
|
|
next(streamErr, keys);
|
|
});
|
|
|
|
}, function(err, results) {
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
results = _.flatten(results);
|
|
var operations = [];
|
|
for(var i = 0; i < results.length; i++) {
|
|
operations.push({
|
|
type: 'del',
|
|
key: results[i]
|
|
});
|
|
}
|
|
self.db.batch(operations, function(err) {
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
callback(null, operations.length);
|
|
});
|
|
});
|
|
};
|
|
|
|
WalletService.prototype._removeAllWallets = function(callback) {
|
|
var self = this;
|
|
var operations = [];
|
|
|
|
var start = self._encoding.servicePrefix;
|
|
var end = new Buffer.concat([ start, new Buffer('ff', 'hex') ]);
|
|
|
|
var stream = self.db.createKeyStream({
|
|
gte: start,
|
|
lte: end
|
|
});
|
|
|
|
var streamErr = null;
|
|
stream.on('error', function(err) {
|
|
streamErr = err;
|
|
});
|
|
|
|
stream.on('data', function(data) {
|
|
operations.push({ type: 'del', key: data });
|
|
});
|
|
|
|
stream.on('end', function() {
|
|
self.db.batch(operations, function(err) {
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
callback(null, operations.length);
|
|
});
|
|
});
|
|
};
|
|
|
|
WalletService.prototype._getAddresses = function(walletId, callback) {
|
|
var self = this;
|
|
var key = self._encoding.encodeWalletAddressesKey(walletId);
|
|
self.db.get(key, function(err, value) {
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
if (!value) {
|
|
return callback(null, []);
|
|
}
|
|
callback(null, self._encoding.decodeWalletAddressesValue(value));
|
|
});
|
|
};
|
|
|
|
WalletService.prototype._createWallet = function(walletId, callback) {
|
|
var self = this;
|
|
var key = self._encoding.encodeWalletAddressesKey(walletId);
|
|
self.db.get(key, function(err) {
|
|
if (err && ((/notfound/i).test(err) || err.notFound)) {
|
|
var value = self._encoding.encodeWalletAddressesValue([]);
|
|
return self.db.put(key, value, callback);
|
|
}
|
|
callback();
|
|
});
|
|
};
|
|
|
|
WalletService.prototype._isJobQueueReady = function() {
|
|
|
|
var self = this;
|
|
|
|
self._jobs.rforEach(function(value, key) {
|
|
if ((value.status === 'complete' || value.status === 'error') && value.reported) {
|
|
self._jobs.del(key);
|
|
}
|
|
});
|
|
|
|
return self._jobs.length < self._MAX_QUEUE;
|
|
|
|
};
|
|
|
|
WalletService.prototype._jobCompletionCallback = function(err, results) {
|
|
|
|
this.db.resumeSync();
|
|
|
|
log.info('Completed job: ', results.jobId);
|
|
|
|
var jobId = results.jobId;
|
|
var job = this._jobs.get(jobId);
|
|
|
|
if (!job) {
|
|
log.error('ERROR: Could not locate job id: ' + jobId +
|
|
' in the list of jobs. It may have been purged already although it should not have.');
|
|
return;
|
|
}
|
|
|
|
job.progress = 1.0;
|
|
job.endtime = Date.now();
|
|
|
|
if (err) {
|
|
job.status = 'error';
|
|
job.message = err.message;
|
|
return;
|
|
}
|
|
|
|
job.status = 'complete';
|
|
job.message = results;
|
|
job.reported = false;
|
|
};
|
|
|
|
WalletService.prototype._importAddresses = function(walletId, addresses, jobId, callback) {
|
|
var self = this;
|
|
|
|
var jobResults = { jobId: jobId };
|
|
|
|
var job = {
|
|
starttime: Date.now(),
|
|
fn: 'importAddresses',
|
|
progress: 0,
|
|
projectedendtime: null
|
|
};
|
|
|
|
this._jobs.set(jobId, job);
|
|
|
|
|
|
self._getAddresses(walletId, function(err, oldAddresses) {
|
|
if(err) {
|
|
return callback(err, jobResults);
|
|
}
|
|
|
|
log.info('loaded existing addresses, count: ', oldAddresses.length);
|
|
async.parallel(
|
|
[
|
|
self._getUTXOIndexOperations.bind(self, walletId, addresses, jobId),
|
|
self._getTxidIndexOperations.bind(self, walletId, addresses, jobId)
|
|
],
|
|
function(err, results) {
|
|
if(err) {
|
|
return callback(err, jobResults);
|
|
}
|
|
|
|
var now = Date.now();
|
|
job.progress = 0.50;
|
|
job.projectedendtime = now + (now - job.starttime);
|
|
|
|
var operations = results[0].concat(results[1]);
|
|
|
|
operations.push({
|
|
type: 'put',
|
|
key: self._encoding.encodeWalletAddressesKey(walletId),
|
|
value: self._encoding.encodeWalletAddressesValue(oldAddresses.concat(addresses))
|
|
});
|
|
|
|
self.db.batch(operations, function(err) {
|
|
if(err) {
|
|
return callback(err, jobResults);
|
|
}
|
|
|
|
self._loadAllAddresses(function(err) {
|
|
if(err) {
|
|
return callback(err, jobResults);
|
|
}
|
|
|
|
self._loadAllBalances(function(err) {
|
|
if(err) {
|
|
return callback(err, jobResults);
|
|
}
|
|
callback(null, jobResults);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
);
|
|
});
|
|
};
|
|
|
|
WalletService.prototype._getUTXOIndexOperations = function(walletId, addresses, jobId, callback) {
|
|
var self = this;
|
|
|
|
var balance = 0;
|
|
|
|
self._getBalance(walletId, {}, function(err, initialBalance) {
|
|
if(err && !err.notFound) {
|
|
return callback(err);
|
|
}
|
|
|
|
if(initialBalance) {
|
|
balance = initialBalance;
|
|
}
|
|
|
|
log.info('Initial balance of walletId: ' + walletId + ' is: ' + Unit.fromSatoshis(balance).toBTC() + ' BTC.');
|
|
log.info('Starting to gather utxos for walletId: ' + walletId);
|
|
self.node.services.address.getUtxos(addresses, false, function(err, utxos) {
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
log.info('completed gathering utxos: ', utxos.length);
|
|
var operations = [];
|
|
|
|
for(var i = 0; i < utxos.length; i++) {
|
|
var utxo = utxos[i];
|
|
|
|
balance += utxo.satoshis;
|
|
|
|
operations.push({
|
|
type: 'put',
|
|
key: self._encoding.encodeWalletUtxoKey(walletId, utxo.txid, utxo.outputIndex),
|
|
value: self._encoding.encodeWalletUtxoValue(utxo.height, utxo.satoshis, utxo.script)
|
|
});
|
|
|
|
operations.push({
|
|
type: 'put',
|
|
key: self._encoding.encodeWalletUtxoSatoshisKey(walletId, utxo.satoshis, utxo.txid, utxo.outputIndex),
|
|
value: self._encoding.encodeWalletUtxoSatoshisValue(utxo.height, utxo.script)
|
|
});
|
|
}
|
|
|
|
operations.push({
|
|
type: 'put',
|
|
key: self._encoding.encodeWalletBalanceKey(walletId),
|
|
value: self._encoding.encodeWalletBalanceValue(balance)
|
|
});
|
|
|
|
log.info('Final balance for walletId: ' + walletId + ' is: ' + Unit.fromSatoshis(balance).toBTC() + ' BTC.');
|
|
callback(null, operations);
|
|
});
|
|
});
|
|
};
|
|
|
|
WalletService.prototype._getTxidIndexOperations = function(walletId, addresses, jobId, callback) {
|
|
var self = this;
|
|
var txids = {};
|
|
|
|
var logCount = 0;
|
|
async.eachLimit(addresses, 10, function(address, next) {
|
|
self.node.services.address.getAddressTxidsWithHeights(address, null, function(err, tmpTxids) {
|
|
if(err) {
|
|
return next(err);
|
|
}
|
|
if (logCount++ % 1000 === 0) {
|
|
log.info('loaded address txids, total count: ', Object.keys(txids).length);
|
|
}
|
|
txids = _.merge(txids, tmpTxids);
|
|
return next();
|
|
});
|
|
}, function(err) {
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
var operations = Object.keys(txids).map(function(txid) {
|
|
assert(txid.length === 64, 'WalletService, Txid: ' + txid + ' with length: ' + txid.length + ' does not resemble a txid.');
|
|
return {
|
|
type: 'put',
|
|
key: self._encoding.encodeWalletTransactionKey(walletId, txids[txid], txid)
|
|
};
|
|
});
|
|
|
|
callback(null, operations);
|
|
});
|
|
};
|
|
|
|
WalletService.prototype._storeAddresses = function(walletId, addresses, callback) {
|
|
var key = this._encoding.encodeWalletAddressesKey(walletId);
|
|
var value = this._encoding.encodeWalletValue(addresses);
|
|
this.db.put(key, value, callback);
|
|
};
|
|
|
|
WalletService.prototype._storeBalance = function(walletId, balance, callback) {
|
|
var key = this._encoding.encodeWalletBalanceKey(walletId);
|
|
var value = this._encoding.encodeWalletBalanceValue(balance);
|
|
this.db.put(key, value, callback);
|
|
};
|
|
|
|
WalletService.prototype._processStartEndOptions = function(req, callback) {
|
|
var self = this;
|
|
|
|
if (req.query.start >= 0 && req.query.end >= 0) {
|
|
|
|
var heights = [];
|
|
self.node.services.timestamp.getBlockHeights([
|
|
utils.normalizeTimeStamp(req.query.start),
|
|
utils.normalizeTimeStamp(req.query.end)
|
|
],
|
|
|
|
function(err, hashTuple) {
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
hashTuple.forEach(function(hash) {
|
|
self.node.services.bitcoind._tryAllClients(function(client, done) {
|
|
client.getBlock(hash, function(err, response) {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
done(null, heights.push(response.result.height));
|
|
});
|
|
}, function(err) {
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
if (heights.length > 1) {
|
|
callback(null, heights);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
} else {
|
|
|
|
setImmediate(function() {
|
|
callback(null, [req.query.start, req.query.end]);
|
|
});
|
|
|
|
}
|
|
};
|
|
|
|
WalletService.prototype._endpointJobs = function() {
|
|
|
|
var self = this;
|
|
|
|
return function(req, res) {
|
|
|
|
var count = 0;
|
|
self._jobs.rforEach(function(value) {
|
|
if ((value.state === 'complete' || value.state === 'error') && value.reported) {
|
|
count++;
|
|
}
|
|
});
|
|
|
|
res.status(200).jsonp({ jobCount: self._jobs.length - count });
|
|
};
|
|
|
|
};
|
|
|
|
WalletService.prototype._endpointJobStatus = function() {
|
|
|
|
var self = this;
|
|
|
|
return function(req, res) {
|
|
var jobId = req.params.jobId;
|
|
var job = self._jobs.get(jobId);
|
|
if (!jobId || !job) {
|
|
return utils.sendError(new Error('Job not found. ' +
|
|
'The job results may have been purged to make room for new jobs.'), res);
|
|
}
|
|
job.reported = true;
|
|
return res.status(201).jsonp(job);
|
|
};
|
|
|
|
};
|
|
|
|
WalletService.prototype._setupReadOnlyRoutes = function(app) {
|
|
var s = this;
|
|
|
|
app.get('/wallets/:walletId/utxos',
|
|
s._endpointUTXOs()
|
|
);
|
|
app.get('/wallets/:walletId/balance',
|
|
s._endpointGetBalance()
|
|
);
|
|
app.get('/wallets/dump',
|
|
s._endpointDumpAllWallets()
|
|
);
|
|
app.get('/wallets/:walletId',
|
|
s._endpointGetAddresses()
|
|
);
|
|
app.get('/wallets/:walletId/transactions',
|
|
s._endpointGetTransactions()
|
|
);
|
|
app.get('/wallets',
|
|
s._endpointGetWalletIds()
|
|
);
|
|
app.get('/jobs/:jobId',
|
|
s._endpointJobStatus()
|
|
);
|
|
app.get('/jobs',
|
|
s._endpointJobs()
|
|
);
|
|
};
|
|
|
|
WalletService.prototype._setupWriteRoutes = function(app) {
|
|
var s = this;
|
|
var v = validators;
|
|
|
|
app.post('/wallets/:walletId',
|
|
s._endpointRegisterWallet()
|
|
);
|
|
app.delete('/wallets/:walletId',
|
|
s._endpointRemoveWallet()
|
|
);
|
|
app.delete('/wallets/',
|
|
s._endpointRemoveAllWallets()
|
|
);
|
|
app.put('/wallets/:walletId/addresses',
|
|
s._endpointPutAddresses()
|
|
);
|
|
app.post('/wallets/:walletId/addresses',
|
|
upload.single('addresses'),
|
|
v.checkAddresses,
|
|
s._endpointPostAddresses()
|
|
);
|
|
app.put('/wallets/:walletId/addresses/resync',
|
|
s._endpointResyncAddresses()
|
|
);
|
|
};
|
|
|
|
|
|
WalletService.prototype.setupRoutes = function(app) {
|
|
|
|
app.use(bodyParser.json());
|
|
this._setupReadOnlyRoutes(app);
|
|
this._setupWriteRoutes(app);
|
|
|
|
};
|
|
|
|
WalletService.prototype.getRoutePrefix = function() {
|
|
return 'wallet-api';
|
|
};
|
|
|
|
module.exports = WalletService;
|
|
|