Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
var util = require('util')
var bitcore = require('bitcore')
var _ = bitcore.deps._
var $ = bitcore.util.preconditions
var BufferUtil = bitcore.util.buffer
var JSUtil = bitcore.util.js
var BlockHeader = bitcore.BlockHeader
var BufferReader = bitcore.encoding.BufferReader
var BufferWriter = bitcore.encoding.BufferWriter
var Script = bitcore.Script
var zeroHash = new Buffer('0000000000000000000000000000000000000000000000000000000000000000', 'hex')
var PrivateBlockHeader = module.exports = function (arg) {
if (!(this instanceof PrivateBlockHeader)) {
return new PrivateBlockHeader(arg)
}
_.extend(this, PrivateBlockHeader._from(arg))
return this
'use strict';
var bitcore = require('bitcore');
var $ = bitcore.util.preconditions;
var _ = bitcore.deps._;
var BufferUtil = bitcore.util.buffer;
var NULL = '0000000000000000000000000000000000000000000000000000000000000000';
function BlockChain() {
this.tip = NULL;
this.work = {};
this.work[NULL] = 0;
this.height = {};
this.height[NULL] = -1;
this.hashByHeight = {
'-1': NULL
};
this.next = {};
this.prev = {};
}
'use strict';
var bitcore = require('bitcore');
var Promise = require('bluebird');
var $ = bitcore.util.preconditions;
var _ = bitcore.deps._;
var EventEmitter = require('eventemitter2').EventEmitter2;
var util = require('util');
function EventBus() {
this.handlers = {};
}
util.inherits(EventBus, EventEmitter);
EventBus.prototype.process = function(e) {
$.checkArgument(_.isObject(e));
var self = this;
var done = [];
var processEvent = function(event) {
done = done.concat(event);
BlockService.blockRPCtoBitcore = function(blockData) {
$.checkArgument(blockData, 'blockData is required');
var block = new bitcore.Block({
header: new bitcore.BlockHeader({
version: blockData.version,
prevHash: blockData.previousblockhash ?
bitcore.util.buffer.reverse(
new bitcore.deps.Buffer(blockData.previousblockhash, 'hex')
) : bitcore.util.buffer.emptyBuffer(32),
time: blockData.time,
nonce: blockData.nonce,
bits: new bitcore.deps.bnjs(
new bitcore.deps.Buffer(blockData.bits, 'hex')
).toNumber(),
merkleRoot: bitcore.util.buffer.reverse(
new bitcore.deps.Buffer(blockData.merkleroot, 'hex')
)
}),
transactions: blockData.transactions
});
block.height = blockData.height;
return block;
};
'use strict';
var bitcore = require('bitcore');
var _ = bitcore.deps._;
var $ = bitcore.util.preconditions;
var Address = bitcore.Address;
var BitcoreNode = require('../../');
var Addresses = {};
var node;
Addresses.setNode = function(aNode) {
node = aNode;
};
/*
* params
*/
'use strict';
var util = require('util');
var bindings = require('bindings')('bitcoind.node');
var mkdirp = require('mkdirp');
var fs = require('fs');
var bitcore = require('bitcore');
var $ = bitcore.util.preconditions;
var _ = bitcore.deps._;
var index = require('../');
var log = index.log;
var Service = require('../service');
/**
* Provides an interface to native bindings to Bitcoin Core
* @param {Object} options
* @param {String} options.datadir - The bitcoin data directory
* @param {Node} options.node - A reference to the node
*/
function Bitcoin(options) {
if (!(this instanceof Bitcoin)) {
return new Bitcoin(options);
}
this._reindex = false;
'use strict';
var util = require('util');
var EventEmitter = require('eventemitter2').EventEmitter2;
var Promise = require('bluebird').Promise;
var bitcore = require('bitcore');
var Networks = bitcore.Networks;
var $ = bitcore.util.preconditions;
var _ = bitcore.deps._;
var p2p = require('bitcore-p2p');
var Peer = p2p.Peer;
function NetworkMonitor(eventBus, peer) {
$.checkArgument(eventBus);
$.checkArgument(peer);
this.bus = eventBus;
this.peer = peer;
this.messages = new p2p.Messages({
network: this.peer.network,
});
this.ignoreInv = true;
this.setupPeer(peer);
}
util.inherits(NetworkMonitor, EventEmitter);
BlockService.blockRPCtoBitcore = function(blockData) {
$.checkArgument(blockData, 'blockData is required');
var block = new bitcore.Block({
header: new bitcore.BlockHeader({
version: blockData.version,
prevHash: blockData.previousblockhash ?
bitcore.util.buffer.reverse(
new bitcore.deps.Buffer(blockData.previousblockhash, 'hex')
) : bitcore.util.buffer.emptyBuffer(32),
time: blockData.time,
nonce: blockData.nonce,
bits: new bitcore.deps.bnjs(
new bitcore.deps.Buffer(blockData.bits, 'hex')
).toNumber(),
merkleRoot: bitcore.util.buffer.reverse(
new bitcore.deps.Buffer(blockData.merkleroot, 'hex')
)
}),
transactions: blockData.transactions
});
block.height = blockData.height;
return block;
};
'use strict';
var Promise = require('bluebird');
var bitcore = require('bitcore');
var _ = bitcore.deps._;
var $ = bitcore.util.preconditions;
var Transaction = bitcore.Transaction;
var errors = require('../../lib/errors');
var Transactions = {};
var node;
Transactions.setNode = function(aNode) {
node = aNode;
};
/*
* params
*/
var config = require('config');
var LevelUp = require('levelup');
var Promise = require('bluebird');
var RPC = require('bitcoind-rpc');
var bitcore = require('bitcore');
var BufferUtil = bitcore.util.buffer;
var Block = bitcore.Block;
var errors = require('../errors');
var BlockChain = require('../blockchain');
var genesisBlocks = require('../data/genesis');
var TransactionService = require('./transaction');
var $ = bitcore.util.preconditions;
var JSUtil = bitcore.util.js;
var _ = bitcore.deps._;
var helper = function(index) {
return function(maybeHash) {
if (_.isString(maybeHash)) {
return index + maybeHash;
} else if (bitcore.util.buffer.isBuffer(maybeHash)) {
return index + maybeHash.toString('hex');
} else if (maybeHash instanceof bitcore.Block) {
return index + maybeHash.id;
} else {
throw new bitcore.errors.InvalidArgument();
}
};
};
var Index = {