163 lines
4.0 KiB
JavaScript
163 lines
4.0 KiB
JavaScript
'use strict';
|
|
|
|
var BaseService = require('../../service');
|
|
var inherits = require('util').inherits;
|
|
var Encoding = require('./encoding');
|
|
var LRU = require('lru-cache');
|
|
|
|
const REORG_BUFFER = 6;
|
|
|
|
function UtxoService(options) {
|
|
BaseService.call(this, options);
|
|
this._operations = [];
|
|
this._createCache({ max: 500000, dispose: this._getUtxoOperations.bind(this) });
|
|
this._exclusionIndexes = [];
|
|
}
|
|
|
|
inherits(UtxoService, BaseService);
|
|
|
|
UtxoService.dependencies = ['db'];
|
|
|
|
UtxoService.prototype.start = function(callback) {
|
|
var self = this;
|
|
|
|
self.db = this.node.services.db;
|
|
|
|
self.db.getPrefix(self.name, function(err, prefix) {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
self.prefix = prefix;
|
|
self.encoding = new Encoding(self.prefix);
|
|
callback();
|
|
});
|
|
};
|
|
|
|
UtxoService.prototype.stop = function(callback) {
|
|
if (callback) {
|
|
setImmediate(callback);
|
|
}
|
|
};
|
|
|
|
UtxoService.prototype._processInputs = function(tx, inputs, connect) {
|
|
|
|
var operations = [];
|
|
for(var i = 0; i < inputs.length; i++) {
|
|
var input = inputs[i];
|
|
|
|
var key = input.prevHash + input.outputIndex;
|
|
|
|
if (input.prevTxId === tx.hash) {
|
|
this._exlusionIndexes.push(i);
|
|
continue;
|
|
}
|
|
|
|
var ops = this._moveOutput(key, connect);
|
|
operations = operations.concat(ops);
|
|
}
|
|
|
|
return operations;
|
|
|
|
};
|
|
|
|
UtxoService.prototype._processOutputs = function(tx, outputs, block, connect) {
|
|
|
|
var operations = [];
|
|
for(var i = 0; i < outputs.length; i++) {
|
|
|
|
var output = outputs[i];
|
|
var key = tx.hash + i;
|
|
|
|
if (this._exclusionIndexes.indexOf(i) > -1) {
|
|
continue;
|
|
}
|
|
|
|
if (connect) {
|
|
//when the cache is full, we will write out.
|
|
return this._setCache(key, block, output);
|
|
}
|
|
|
|
return this._cache.del(key);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
UtxoService.prototype._setCache = function(key, block, output, value) {
|
|
|
|
if (!value) {
|
|
value = {
|
|
output: output,
|
|
height: block.__height,
|
|
hash: block.hash
|
|
};
|
|
}
|
|
|
|
this._cache.set(key, value); // key = 36 bytes, value = (8 + 25ish) + 36 = 69 bytes
|
|
|
|
};
|
|
|
|
UtxoService.prototype._moveOutput = function(key, connect) {
|
|
|
|
if (connect) {
|
|
self._cache.del(key);
|
|
return { action: 'del', key: key };
|
|
}
|
|
|
|
// this should only happen during a reorg, hopefully this is an infrequent occurence
|
|
// the ramifications are that comsumers of this data will need to make an additional
|
|
// lookup of the tx index. We are ok with trade-off for performance.
|
|
return { action: 'put', key: key, value: null };
|
|
|
|
};
|
|
|
|
UtxoService.prototype.blockHandler = function(block, connect) {
|
|
|
|
var self = this;
|
|
|
|
self._currentBlockHeight = block.__height;
|
|
self._exclusionIndexes.length = 0;
|
|
var operations = [];
|
|
|
|
for(var i = 0; i < block.transactions.length; i++) {
|
|
|
|
var tx = block.transactions[i];
|
|
var inputs = tx.inputs;
|
|
var outputs = tx.outputs;
|
|
|
|
if (!tx.isCoinbase()) {
|
|
operations = self._processInputs(tx, inputs, connect).concat(operations);
|
|
}
|
|
|
|
self._processOutputs(tx, outputs, block, connect);
|
|
}
|
|
|
|
operations = this._operations.concat(operations);
|
|
this._operations.length = 0;
|
|
|
|
return operations;
|
|
};
|
|
|
|
UtxoService.prototype._getUtxoOperations = function(key, value) {
|
|
if (value.height + REORG_BUFFER >= self._currentHeight) {
|
|
log.error('Writing utxos to the database before ' + REORG_BUFFER + ' confirmation blocks.' +
|
|
' The internal cache might be too small or the system does not have enough memory.');
|
|
}
|
|
this._operations.push({
|
|
action: 'put',
|
|
key: this._getOperationsKey(key, value),
|
|
value: this._getOperationsValue(value)
|
|
});
|
|
};
|
|
|
|
UtxoService.prototype._getOperationsKey = function(key, value) {
|
|
var address = utils.getAddressStringFromScript(value.output.script, this.node.network);
|
|
return self.encoding.encodeUtxoIndexKey(address, key.slice(0, 32), parseInt(key.slice(32)));
|
|
};
|
|
|
|
UtxoService.prototype._getOperationsValue = function(value) {
|
|
return self.encoding.encodeUtxoIndexValue(value.height, value.output.satoshis, value.output.script);
|
|
};
|
|
|
|
module.exports = UtxoService;
|