163 lines
3.6 KiB
JavaScript
163 lines
3.6 KiB
JavaScript
'use strict';
|
|
|
|
require('classtool');
|
|
|
|
function spec() {
|
|
|
|
var Block = require('bitcore/Block').class(),
|
|
networks = require('bitcore/networks'),
|
|
Parser = require('bitcore/util/BinaryParser').class(),
|
|
fs = require('fs'),
|
|
Buffer = require('buffer').Buffer,
|
|
glob = require('glob'),
|
|
async = require('async');
|
|
|
|
function BlockExtractor(dataDir, network) {
|
|
|
|
var self = this;
|
|
var path = dataDir + '/blocks/blk*.dat';
|
|
|
|
self.dataDir = dataDir;
|
|
self.files = glob.sync(path);
|
|
self.nfiles = self.files.length;
|
|
|
|
if (self.nfiles === 0)
|
|
throw new Error('Could not find block files at: ' + path);
|
|
|
|
self.currentFileIndex = 0;
|
|
self.isCurrentRead = false;
|
|
self.currentBuffer = null;
|
|
self.currentParser = null;
|
|
self.network = network === 'testnet' ? networks.testnet: networks.livenet;
|
|
self.magic = self.network.magic.toString('hex');
|
|
}
|
|
|
|
BlockExtractor.prototype.currentFile = function() {
|
|
var self = this;
|
|
|
|
return self.files[self.currentFileIndex];
|
|
};
|
|
|
|
|
|
BlockExtractor.prototype.nextFile = function() {
|
|
var self = this;
|
|
|
|
if (self.currentFileIndex < 0) return false;
|
|
|
|
var ret = true;
|
|
|
|
self.isCurrentRead = false;
|
|
self.currentBuffer = null;
|
|
self.currentParser = null;
|
|
|
|
if (self.currentFileIndex < self.nfiles - 1) {
|
|
self.currentFileIndex++;
|
|
}
|
|
else {
|
|
self.currentFileIndex=-1;
|
|
ret = false;
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
BlockExtractor.prototype.readCurrentFileSync = function() {
|
|
var self = this;
|
|
|
|
if (self.currentFileIndex < 0 || self.isCurrentRead) return;
|
|
|
|
|
|
self.isCurrentRead = true;
|
|
|
|
var fname = self.currentFile();
|
|
if (!fname) return;
|
|
|
|
|
|
var stats = fs.statSync(fname);
|
|
|
|
var size = stats.size;
|
|
|
|
console.log('Reading Blockfile %s [%d MB]',
|
|
fname, parseInt(size/1024/1024));
|
|
|
|
var fd = fs.openSync(fname, 'r');
|
|
|
|
var buffer = new Buffer(size);
|
|
|
|
fs.readSync(fd, buffer, 0, size, 0);
|
|
|
|
self.currentBuffer = buffer;
|
|
self.currentParser = new Parser(buffer);
|
|
};
|
|
|
|
|
|
|
|
BlockExtractor.prototype.getNextBlock = function(cb) {
|
|
var self = this;
|
|
|
|
var b;
|
|
var magic;
|
|
async.series([
|
|
function (a_cb) {
|
|
|
|
async.whilst(
|
|
function() {
|
|
return (!magic);
|
|
},
|
|
function(w_cb) {
|
|
|
|
self.readCurrentFileSync();
|
|
|
|
if (self.currentFileIndex < 0) return cb();
|
|
|
|
|
|
magic = self.currentParser ? self.currentParser.buffer(4).toString('hex')
|
|
: null ;
|
|
|
|
if (!self.currentParser || self.currentParser.eof() || magic === '00000000') {
|
|
magic = null;
|
|
if (self.nextFile()) {
|
|
console.log('Moving forward to file:' + self.currentFile() );
|
|
return w_cb();
|
|
}
|
|
else {
|
|
console.log('Finished all files');
|
|
magic = null;
|
|
return w_cb();
|
|
}
|
|
}
|
|
else {
|
|
return w_cb();
|
|
}
|
|
}, a_cb);
|
|
},
|
|
function (a_cb) {
|
|
if (!magic) return a_cb();
|
|
|
|
if (magic !== self.magic) {
|
|
var e = new Error('CRITICAL ERROR: Magic number mismatch: ' +
|
|
magic + '!=' + self.magic);
|
|
return a_cb(e);
|
|
}
|
|
|
|
// spacer?
|
|
self.currentParser.word32le();
|
|
return a_cb();
|
|
},
|
|
function (a_cb) {
|
|
if (!magic) return a_cb();
|
|
|
|
b = new Block();
|
|
b.parse(self.currentParser);
|
|
b.getHash();
|
|
return a_cb();
|
|
},
|
|
], function(err) {
|
|
return cb(err,b);
|
|
});
|
|
};
|
|
|
|
return BlockExtractor;
|
|
}
|
|
module.defineClass(spec);
|
|
|