RanchiMall/flosight-api
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reliably update inputs. Self-healing. Audit Mongo blockheights

Browse Source
This commit is contained in:
tenthirtyone 2017-08-24 14:28:21 -04:00
parent a3941f75ef
commit 2ccaf2fce0
6 changed files with 69 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
server/index.js
View File

@ -9,11 +9,16 @@ logger.log('debug',
db.connect(config.mongodb.uri, config.mongodb.options);
db.connection.once('open', () => {
if (config.start_node) Bcoin.start();
Api.listen(config.api.port, () => {
logger.log('debug',
'listening on port 3000');
db.connection.once('open', () => {
// DB Audit returns best height to node
db.blocks.findMissingBlocks((err, lastBestHeight) => {
// Pass height to node to start Sync
if (config.start_node) Bcoin.start(lastBestHeight);
Api.listen(config.api.port, () => {
logger.log('debug',
'listening on port 3000');
});
});
});

32
server/lib/db/blocks.js
View File

@ -2,7 +2,6 @@ const Block = require('../../models/block.js');
const logger = require('../logger');
const config = require('../../config');
const block = new Block();
let bestBlockHeight = 0;
@ -20,27 +19,48 @@ function bestHeight(height) {
}
function getRawBlock(hash, cb) {
return block.getRawBlock(hash, cb);
return Block.getRawBlock(hash, cb);
}
function byHeight(height, cb) {
return block.byHeight(height, cb);
return Block.byHeight(height, cb);
}
function getTopBlocks(cb) {
return block.last(cb);
return Block.last(cb);
}
function getByHash(hash, cb) {
return block.byHash(hash, cb);
return Block.byHash(hash, cb);
}
function getLastBlock(cb) {
return block.last(cb)
return Block.last(cb)
.limit(1);
}
// Returns the missing block if it exists. Otherwise, return tip.
function findMissingBlocks(cb) {
logger.log('debug',
'Verifying Mongo Blockchain');
return Block.getHeights((err, blocks) => {
if (err) {
return cb(err);
}
// Blocks are in ascending order
let lastGoodHeight = 0;
blocks.forEach((block) => {
if (lastGoodHeight !== block.height - 1) {
return lastGoodHeight;
}
lastGoodHeight = block.height;
});
return lastGoodHeight;
});
}
module.exports = {
findMissingBlocks,
getRawBlock,
getTopBlocks,
getLastBlock,

22
server/lib/db/transactions.js
View File

@ -2,44 +2,45 @@ const Transactions = require('../../models/transaction.js');
const config = require('../../config');
const logger = require('../logger');
const Txs = new Transactions();
const MAX_PAGE_TXS = config.api.max_page_txs;
function getEmptyInputs(cb) {
return Txs.getEmptyInputs(cb);
return Transactions.getEmptyInputs(cb);
}
function getTopTransactions(cb) {
return Txs.last(cb);
return Transactions.last(cb);
}
function getTxById(txid, cb) {
return Txs.byId(txid, cb);
return Transactions.byId(txid, cb);
}
function getTxByBlock(blockHash, page, limit, cb) {
return Txs.byBlockHash(blockHash, cb)
return Transactions.byBlockHash(blockHash, cb)
.skip(limit * page);
}
function getTxByAddress(address, page, limit, cb) {
return Txs.byAddress(address, cb)
return Transactions.byAddress(address, cb)
.limit(limit)
.skip(limit * page);
}
function getTxCountByBlock(blockHash, cb) {
return Txs.countByBlock(blockHash, cb);
return Transactions.countByBlock(blockHash, cb);
}
function getTxCountByAddress(address, cb) {
return Txs.countByAddress(address, cb);
return Transactions.countByAddress(address, cb);
}
function updateInput(txid, inputid, value, address) {
return Txs.updateInput(txid, inputid, value, address);
return Transactions.updateInput(txid, inputid, value, address);
}
// Updates empty inputs with prevout addr & value
function auditInputs() {
getEmptyInputs(
(err, txs) => {
@ -48,9 +49,6 @@ function auditInputs() {
`No Empty Inputs found: ${err.err}`);
}
// For each tx with unmarked inputs
logger.log('debug',
`Found ${txs.length} txs with inputs to update`);
return txs.forEach((inputTx) => {
inputTx.inputs.forEach((input) => {
const txHash = input.prevout.hash;

3
server/lib/node/index.js
View File

@ -9,11 +9,12 @@ const db = require('../../lib/db');
const node = new FullNode(config.bcoin);
let doneSyncing = false;
function start() {
function start(bestBlockHeight) {
node.open()
.then(() => {
node.connect()
.then(() => {
node.reset(bestBlockHeight);
node.startSync();
});
});

16
server/models/block.js
View File

@ -31,26 +31,26 @@ const BlockSchema = new Schema({
BlockSchema.index({ hash: 1 });
BlockSchema.index({ height: 1 });
BlockSchema.methods.byHeight = function blockByHeight(height, cb) {
BlockSchema.statics.byHeight = function blockByHeight(height, cb) {
return this.model('Block').findOne(
{ height },
cb);
};
BlockSchema.methods.byHash = function byHash(hash, cb) {
BlockSchema.statics.byHash = function byHash(hash, cb) {
return this.model('Block').findOne(
{ hash },
cb);
};
BlockSchema.methods.getRawBlock = function getRawBlock(hash, cb) {
BlockSchema.statics.getRawBlock = function getRawBlock(hash, cb) {
return this.model('Block').findOne(
{ hash },
{ rawBlock: 1 },
cb);
};
BlockSchema.methods.last = function lastBlocks(cb) {
BlockSchema.statics.last = function lastBlocks(cb) {
return this.model('Block').find(
{},
cb)
@ -58,4 +58,12 @@ BlockSchema.methods.last = function lastBlocks(cb) {
.sort({ height: -1 });
};
BlockSchema.statics.getHeights = function findMissing(cb) {
return this.model('Block').find(
{},
{ height: 1 },
cb)
.sort({ height: 1 });
};
module.exports = mongoose.model('Block', BlockSchema);

20
server/models/transaction.js
View File

@ -32,24 +32,24 @@ TransactionSchema.index({ 'outputs.address': 1 });
TransactionSchema.index({ 'inputs.address': 1 });
TransactionSchema.methods.byId = function txById(txid, cb) {
TransactionSchema.statics.byId = function txById(txid, cb) {
return this.model('Transaction').findOne(
{ hash: txid },
cb);
};
TransactionSchema.methods.byHash = function txByHash(hash, cb) {
TransactionSchema.statics.byHash = function txByHash(hash, cb) {
return this.byId(hash, cb);
};
TransactionSchema.methods.byBlockHash = function txByBlockHash(hash, cb) {
TransactionSchema.statics.byBlockHash = function txByBlockHash(hash, cb) {
return this.model('Transaction').find(
{ block: hash },
cb)
.limit(MAX_TXS);
};
TransactionSchema.methods.byAddress = function txByAddress(address, cb) {
TransactionSchema.statics.byAddress = function txByAddress(address, cb) {
return this.model('Transaction').find(
{
$or: [
@ -60,13 +60,13 @@ TransactionSchema.methods.byAddress = function txByAddress(address, cb) {
.limit(MAX_TXS);
};
TransactionSchema.methods.countByBlock = function txByAddress(hash, cb) {
TransactionSchema.statics.countByBlock = function txByAddress(hash, cb) {
return this.model('Transaction').count(
{ block: hash },
cb);
};
TransactionSchema.methods.countByAddress = function txByAddress(address, cb) {
TransactionSchema.statics.countByAddress = function txByAddress(address, cb) {
return this.model('Transaction').count(
{
$or: [
@ -76,7 +76,7 @@ TransactionSchema.methods.countByAddress = function txByAddress(address, cb) {
cb);
};
TransactionSchema.methods.last = function lastTx(cb) {
TransactionSchema.statics.last = function lastTx(cb) {
return this.model('Transaction').find(
{},
cb)
@ -84,7 +84,7 @@ TransactionSchema.methods.last = function lastTx(cb) {
.sort({ height: -1 });
};
TransactionSchema.methods.getEmptyInputs = function getEmptyInputs(cb) {
TransactionSchema.statics.getEmptyInputs = function getEmptyInputs(cb) {
return this.model('Transaction').find({
'inputs.prevout.hash': { $ne: '0000000000000000000000000000000000000000000000000000000000000000' },
'inputs.value': 0,
@ -92,9 +92,7 @@ TransactionSchema.methods.getEmptyInputs = function getEmptyInputs(cb) {
cb);
};
TransactionSchema.methods.updateInput = function updateInput(txid, inputid, value, address) {
logger.log('debug',
`${txid} ${address}value is ${value}`);
TransactionSchema.statics.updateInput = function updateInput(txid, inputid, value, address) {
return this.model('Transaction').findOneAndUpdate(
{ _id: txid, 'inputs._id': inputid },
{