392 lines
9.7 KiB
JavaScript
392 lines
9.7 KiB
JavaScript
'use strict';
|
|
|
|
require('classtool');
|
|
|
|
|
|
function spec() {
|
|
|
|
// blockHash -> txid mapping (to orphanize )/
|
|
var ROOT = 'tx-b-'; //tx-b-<block> => txid
|
|
|
|
// to show tx outs
|
|
var OUTS_ROOT = 'txouts-'; //txouts-<txid>-<n> => [addr, btc_sat]
|
|
|
|
// to sum up addr balance
|
|
var ADDR_ROOT = 'txouts-addr-'; //txouts-addr-<addr>-<ts>-<txid>-<n> => + btc_sat
|
|
var SPEND_ROOT = 'txouts-spend-';//txouts-spend-<txid(out)>-<n(out)> => [txid(in),n(in),ts]
|
|
|
|
// TODO: use bitcore networks module
|
|
var genesisTXID = '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b';
|
|
var CONCURRENCY = 100;
|
|
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
var TransactionRpc = require('./TransactionRpc').class(),
|
|
util = require('bitcore/util/util'),
|
|
levelup = require('levelup'),
|
|
async = require('async'),
|
|
config = require('../config/config');
|
|
|
|
var TransactionDb = function() {
|
|
this.db = levelup(config.leveldb + '/txs');
|
|
};
|
|
|
|
TransactionDb.prototype.drop = function(cb) {
|
|
var self = this;
|
|
var path = config.leveldb + '/txs';
|
|
self.db.close(function() {
|
|
require('leveldown').destroy(path, function () {
|
|
self.db = levelup(path);
|
|
return cb();
|
|
});
|
|
});
|
|
};
|
|
|
|
|
|
// TransactionDb.prototype.fromTxIdOne = function(txid, cb) { TODO
|
|
TransactionDb.prototype.has = function(txid, cb) {
|
|
var self = this;
|
|
|
|
var k = OUTS_ROOT + txid;
|
|
self.db.get(k, function (err,val) {
|
|
|
|
var ret;
|
|
|
|
if (err && err.notFound) {
|
|
err = null;
|
|
ret = false;
|
|
}
|
|
if (typeof val !== undefined) {
|
|
ret = true;
|
|
}
|
|
return cb(err, ret);
|
|
});
|
|
};
|
|
|
|
TransactionDb.prototype.fromTxId = function(txid, cb) {
|
|
var self = this;
|
|
|
|
var k = OUTS_ROOT + txid;
|
|
var ret=[];
|
|
|
|
// outs.
|
|
self.db.createReadStream({start: k, end: k + '~'})
|
|
.on('data', function (data) {
|
|
var k = data.key.split('-');
|
|
var v = data.value.split(':');
|
|
ret.push({
|
|
addr: v[0],
|
|
value_sat: v[1],
|
|
index: k[2],
|
|
});
|
|
})
|
|
.on('error', function (err) {
|
|
return cb(err);
|
|
})
|
|
.on('end', function () {
|
|
var k = SPEND_ROOT + txid;
|
|
var l = ret.length;
|
|
self.db.createReadStream({start: k, end: k + '~'})
|
|
.on('data', function (data) {
|
|
var k = data.key.split('-');
|
|
var v = data.value.split(':');
|
|
for(var i=0; i<l; i++) {
|
|
if (ret[i].index === k[3]) {
|
|
ret[i].spendTxId= v[0];
|
|
ret[i].spendIndex=v[1];
|
|
}
|
|
}
|
|
})
|
|
.on('error', function (err) {
|
|
return cb(err);
|
|
})
|
|
.on('end', function (err) {
|
|
return cb(err, ret);
|
|
});
|
|
});
|
|
};
|
|
|
|
|
|
TransactionDb.prototype.fromTxIdN = function(txid, n, cb) {
|
|
var self = this;
|
|
|
|
var k = OUTS_ROOT + txid + '-' + n;
|
|
|
|
self.db.get(k, function (err,val) {
|
|
if (err && err.notFound) {
|
|
err = null;
|
|
}
|
|
var a = val.split('-');
|
|
return cb(err, val, a[0], a[1]);
|
|
});
|
|
};
|
|
|
|
TransactionDb.prototype.fromAddr = function(addr, cb) {
|
|
var self = this;
|
|
|
|
var k = ADDR_ROOT + addr;
|
|
var ret=[];
|
|
|
|
//
|
|
self.db.createReadStream({start: k, end: k + '~'})
|
|
.on('data', function (data) {
|
|
var k = data.key.split('-');
|
|
var v = data.value.split(':');
|
|
ret.push({
|
|
value_sat: v[0],
|
|
ts: k[3],
|
|
txid: k[4],
|
|
index: k[5],
|
|
});
|
|
})
|
|
.on('error', function (err) {
|
|
return cb(err);
|
|
})
|
|
.on('end', function () {
|
|
async.each(ret, function(o, e_c) {
|
|
var k = SPEND_ROOT + o.txid + '-' + o.index;
|
|
self.db.get(k, function(err, val) {
|
|
if (err && err.notFound) err=null;
|
|
if (err || !val) return e_c(err);
|
|
|
|
var v = val.split(':');
|
|
o.spendTxId= v[0];
|
|
o.spendIndex=v[1];
|
|
return e_c();
|
|
});
|
|
},
|
|
function(err) {
|
|
|
|
console.log('[TransactionDb.js.165]', ret); //TODO
|
|
return cb(err,ret);
|
|
});
|
|
});
|
|
};
|
|
|
|
|
|
|
|
// Only for testing. Very slow (toRm outs to rm, only to speedup)
|
|
TransactionDb.prototype.removeFromTxId = function(txid, toRm, cb) {
|
|
var self = this;
|
|
|
|
async.series([
|
|
function(c) {
|
|
self.db.createReadStream({
|
|
start: OUTS_ROOT + txid,
|
|
end: OUTS_ROOT + txid + '~',
|
|
}).pipe(
|
|
self.db.createWriteStream({type:'del'})
|
|
).on('close', c);
|
|
},
|
|
function(s_c) {
|
|
if (toRm && toRm.length) return s_c();
|
|
|
|
toRm = [];
|
|
self.db.createReadStream({
|
|
start: SPEND_ROOT
|
|
})
|
|
.on('data', function(data) {
|
|
if (data.value.indexOf(txid) >= 0) {
|
|
toRm.push(data.key);
|
|
console.log('To Remove Found', data.key); //TODO
|
|
}
|
|
})
|
|
.on('end', function() {
|
|
return s_c();
|
|
});
|
|
},
|
|
function(s_c) {
|
|
async.each(toRm, function(k,e_c) {
|
|
self.db.del(k,e_c);
|
|
}, s_c);
|
|
}],
|
|
function(err) {
|
|
cb(err);
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
TransactionDb.prototype.adaptTxObject = function(txInfo) {
|
|
|
|
// adapt bitcore TX object to bitcoind JSON response
|
|
txInfo.txid = txInfo.hash;
|
|
|
|
var count = 0;
|
|
txInfo.vin = txInfo.in.map(function (txin) {
|
|
var i = {};
|
|
|
|
if (txin.coinbase) {
|
|
txInfo.isCoinBase = true;
|
|
}
|
|
else {
|
|
i.txid= txin.prev_out.hash;
|
|
i.vout= txin.prev_out.n;
|
|
}
|
|
i.n = count++;
|
|
return i;
|
|
});
|
|
|
|
|
|
count = 0;
|
|
txInfo.vout = txInfo.out.map(function (txout) {
|
|
var o = {};
|
|
|
|
o.value = txout.value;
|
|
o.n = count++;
|
|
|
|
if (txout.addrStr){
|
|
o.scriptPubKey = {};
|
|
o.scriptPubKey.addresses = [txout.addrStr];
|
|
}
|
|
return o;
|
|
});
|
|
};
|
|
|
|
|
|
TransactionDb.prototype.add = function(tx, cb) {
|
|
var self = this;
|
|
var addrs = [];
|
|
var is_new = true;
|
|
|
|
if (tx.hash) self.adaptTxObject(tx);
|
|
|
|
var ts = tx.time;
|
|
|
|
async.series([
|
|
// Input Outpoints (mark them as spended)
|
|
function(p_c) {
|
|
if (tx.isCoinBase) return p_c();
|
|
async.forEachLimit(tx.vin, CONCURRENCY,
|
|
function(i, next_out) {
|
|
self.db.batch()
|
|
.put( SPEND_ROOT + i.txid + '-' + i.vout ,
|
|
tx.txid + ':' + i.n + ':' + ts)
|
|
.write(next_out);
|
|
},
|
|
function (err) {
|
|
if (err) {
|
|
if (!err.message.match(/E11000/)) {
|
|
console.log('ERR at TX %s: %s', tx.txid, err);
|
|
return cb(err);
|
|
}
|
|
}
|
|
return p_c();
|
|
});
|
|
},
|
|
// Parse Outputs
|
|
function(p_c) {
|
|
async.forEachLimit(tx.vout, CONCURRENCY,
|
|
function(o, next_out) {
|
|
if (o.value && o.scriptPubKey &&
|
|
o.scriptPubKey.addresses &&
|
|
o.scriptPubKey.addresses[0] &&
|
|
! o.scriptPubKey.addresses[1] // TODO : not supported
|
|
){
|
|
// This is only to broadcast (WIP)
|
|
// if (addrs.indexOf(o.scriptPubKey.addresses[0]) === -1) {
|
|
// addrs.push(o.scriptPubKey.addresses[0]);
|
|
// }
|
|
|
|
var addr = o.scriptPubKey.addresses[0];
|
|
var sat = o.value * util.COIN;
|
|
self.db.batch()
|
|
.put( OUTS_ROOT + tx.txid + '-' + o.n, addr + ':' + sat)
|
|
.put( ADDR_ROOT + addr + '-' + ts + '-' + tx.txid +
|
|
'-' + o.n, sat)
|
|
.write(next_out);
|
|
|
|
}
|
|
else {
|
|
console.log ('WARN in TX: %s could not parse OUTPUT %d', tx.txid, o.n);
|
|
return next_out();
|
|
}
|
|
},
|
|
function (err) {
|
|
if (err) {
|
|
if (err.message.match(/E11000/)) {
|
|
is_new = false;
|
|
}
|
|
else {
|
|
console.log('ERR at TX %s: %s', tx.txid, err);
|
|
return cb(err);
|
|
}
|
|
}
|
|
return p_c();
|
|
});
|
|
}], function(err) {
|
|
return cb(err, addrs, is_new);
|
|
});
|
|
};
|
|
|
|
TransactionDb.prototype.createFromArray = function(txs, blockHash, next) {
|
|
var self = this;
|
|
|
|
if (!txs) return next();
|
|
|
|
// TODO
|
|
var insertedTxs = [];
|
|
var updatedAddrs = {};
|
|
|
|
async.forEachLimit(txs, CONCURRENCY, function(t, each_cb) {
|
|
if (typeof t === 'string') {
|
|
|
|
// Is it from genesis block? (testnet==livenet)
|
|
// TODO: parse it from networks.genesisTX?
|
|
if (t === genesisTXID) return each_cb();
|
|
|
|
TransactionRpc.getRpcInfo(t, function(err, inInfo) {
|
|
if (!inInfo) return each_cb(err);
|
|
|
|
self.add(inInfo, function(err) {
|
|
if (err || !blockHash) return each_cb(err);
|
|
|
|
self.db.put(ROOT + blockHash, t, function(err) {
|
|
return each_cb(err);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
else {
|
|
self.add(t, function(err) {
|
|
if (err) return each_cb(err);
|
|
|
|
self.db.put(ROOT + blockHash, t.txid, function(err) {
|
|
return each_cb(err);
|
|
});
|
|
});
|
|
}
|
|
},
|
|
function(err) {
|
|
return next(err, insertedTxs, updatedAddrs);
|
|
});
|
|
};
|
|
|
|
|
|
// txs can be a [hashes] or [txObjects]
|
|
TransactionDb.prototype.createFromBlock = function(b, next) {
|
|
var self = this;
|
|
if (!b || !b.tx) return next();
|
|
|
|
return self.createFromArray(b.tx, b.hash, next);
|
|
};
|
|
|
|
|
|
TransactionDb.prototype.setOrphan = function(blockHash, next) {
|
|
// var self = this;
|
|
|
|
//Get Txs
|
|
// TODO
|
|
|
|
//Mark Tx's output as fromOrphan
|
|
//Mark Tx's outpoiunt as fromOrphan. Undo spents
|
|
return next();
|
|
};
|
|
|
|
|
|
return TransactionDb;
|
|
}
|
|
module.defineClass(spec);
|