refactor: rename constants.
This commit is contained in:
Christopher Jeffrey
parent
ad11d33038
commit
0a621238ba
@ -336,8 +336,8 @@ Block.prototype._verify = function _verify(ret) {
|
||||
return false;
|
||||
|
||||
// Size can't be bigger than MAX_BLOCK_SIZE
|
||||
if (this.txs.length > constants.block.maxSize
|
||||
|| this.getVirtualSize() > constants.block.maxSize) {
|
||||
if (this.txs.length > constants.block.MAX_SIZE
|
||||
|| this.getVirtualSize() > constants.block.MAX_SIZE) {
|
||||
ret.reason = 'bad-blk-length';
|
||||
ret.score = 100;
|
||||
return false;
|
||||
|
||||
@ -510,7 +510,7 @@ Chain.prototype._verify = function _verify(block, prev, callback) {
|
||||
// not have a signature. See:
|
||||
// 6a26d2ecb67f27d1fa5524763b49029d7106e91e3cc05743073461a719776192
|
||||
// 9c08a4d78931342b37fd5f72900fb9983087e6f46c4a097d8a1f52c74e28eaf6
|
||||
if (block.ts < constants.block.bip16time)
|
||||
if (block.ts < constants.block.BIP16_TIME)
|
||||
flags &= ~constants.flags.VERIFY_P2SH;
|
||||
|
||||
// Only allow version 2 blocks (coinbase height)
|
||||
@ -751,12 +751,12 @@ Chain.prototype._checkInputs = function _checkInputs(block, prev, flags, callbac
|
||||
// Check for block sigops limits
|
||||
// Start counting P2SH sigops once block
|
||||
// timestamps reach March 31st, 2012.
|
||||
if (block.ts >= constants.block.bip16time)
|
||||
if (block.ts >= constants.block.BIP16_TIME)
|
||||
sigops += tx.getSigops(true);
|
||||
else
|
||||
sigops += tx.getSigops();
|
||||
|
||||
if (sigops > constants.block.maxSigops) {
|
||||
if (sigops > constants.block.MAX_SIGOPS) {
|
||||
return callback(new VerifyError(block,
|
||||
'invalid',
|
||||
'bad-blk-sigops',
|
||||
@ -1980,7 +1980,7 @@ Chain.prototype.getOrphanRoot = function getOrphanRoot(hash) {
|
||||
|
||||
Chain.prototype.getCurrentTarget = function getCurrentTarget(callback) {
|
||||
if (!this.tip)
|
||||
return callback(null, utils.toCompact(network.powLimit));
|
||||
return callback(null, utils.toCompact(network.pow.limit));
|
||||
return this.getTargetAsync(this.tip, null, callback);
|
||||
};
|
||||
|
||||
@ -1995,12 +1995,12 @@ Chain.prototype.getCurrentTarget = function getCurrentTarget(callback) {
|
||||
Chain.prototype.getTargetAsync = function getTargetAsync(last, block, callback) {
|
||||
var self = this;
|
||||
|
||||
if ((last.height + 1) % network.powDiffInterval !== 0) {
|
||||
if (!network.powAllowMinDifficultyBlocks)
|
||||
if ((last.height + 1) % network.pow.diffInterval !== 0) {
|
||||
if (!network.pow.allowMinDifficultyBlocks)
|
||||
return utils.asyncify(callback)(null, this.getTarget(last, block));
|
||||
}
|
||||
|
||||
return last.getAncestors(network.powDiffInterval, function(err, ancestors) {
|
||||
return last.getAncestors(network.pow.diffInterval, function(err, ancestors) {
|
||||
if (err)
|
||||
return callback(err);
|
||||
|
||||
@ -2019,7 +2019,7 @@ Chain.prototype.getTargetAsync = function getTargetAsync(last, block, callback)
|
||||
*/
|
||||
|
||||
Chain.prototype.getTarget = function getTarget(last, block, ancestors) {
|
||||
var powLimit = utils.toCompact(network.powLimit);
|
||||
var powLimit = utils.toCompact(network.pow.limit);
|
||||
var ts, first, i;
|
||||
|
||||
// Genesis
|
||||
@ -2030,16 +2030,16 @@ Chain.prototype.getTarget = function getTarget(last, block, ancestors) {
|
||||
ancestors = last.ancestors;
|
||||
|
||||
// Do not retarget
|
||||
if ((last.height + 1) % network.powDiffInterval !== 0) {
|
||||
if (network.powAllowMinDifficultyBlocks) {
|
||||
if ((last.height + 1) % network.pow.diffInterval !== 0) {
|
||||
if (network.pow.allowMinDifficultyBlocks) {
|
||||
// Special behavior for testnet:
|
||||
ts = block ? (block.ts || block) : utils.now();
|
||||
if (ts > last.ts + network.powTargetSpacing * 2)
|
||||
if (ts > last.ts + network.pow.targetSpacing * 2)
|
||||
return powLimit;
|
||||
|
||||
i = 1;
|
||||
while (ancestors[i]
|
||||
&& last.height % network.powDiffInterval !== 0
|
||||
&& last.height % network.pow.diffInterval !== 0
|
||||
&& last.bits === powLimit) {
|
||||
last = ancestors[i++];
|
||||
}
|
||||
@ -2048,7 +2048,7 @@ Chain.prototype.getTarget = function getTarget(last, block, ancestors) {
|
||||
}
|
||||
|
||||
// Back 2 weeks
|
||||
first = ancestors[network.powDiffInterval - 1];
|
||||
first = ancestors[network.pow.diffInterval - 1];
|
||||
|
||||
assert(first);
|
||||
|
||||
@ -2064,10 +2064,10 @@ Chain.prototype.getTarget = function getTarget(last, block, ancestors) {
|
||||
*/
|
||||
|
||||
Chain.prototype.retarget = function retarget(last, first) {
|
||||
var powTargetTimespan = new bn(network.powTargetTimespan);
|
||||
var powTargetTimespan = new bn(network.pow.targetTimespan);
|
||||
var actualTimespan, target;
|
||||
|
||||
if (network.powNoRetargeting)
|
||||
if (network.pow.noRetargeting)
|
||||
return last.bits;
|
||||
|
||||
actualTimespan = new bn(last.ts - first.ts);
|
||||
@ -2082,8 +2082,8 @@ Chain.prototype.retarget = function retarget(last, first) {
|
||||
target.imul(actualTimespan);
|
||||
target = target.div(powTargetTimespan);
|
||||
|
||||
if (target.cmp(network.powLimit) > 0)
|
||||
target = network.powLimit.clone();
|
||||
if (target.cmp(network.pow.limit) > 0)
|
||||
target = network.pow.limit.clone();
|
||||
|
||||
return utils.toCompact(target);
|
||||
};
|
||||
@ -2410,10 +2410,10 @@ Chain.prototype.checkFinal = function checkFinal(prev, tx, flags, callback, forc
|
||||
|
||||
Chain.prototype.getLocks = function getLocks(tx, flags, entry, callback) {
|
||||
var self = this;
|
||||
var mask = constants.sequenceLocktimeMask;
|
||||
var granularity = constants.sequenceLocktimeGranularity;
|
||||
var disableFlag = constants.sequenceLocktimeDisableFlag;
|
||||
var typeFlag = constants.sequenceLocktimeTypeFlag;
|
||||
var mask = constants.sequence.MASK;
|
||||
var granularity = constants.sequence.GRANULARITY;
|
||||
var disableFlag = constants.sequence.DISABLE_FLAG;
|
||||
var typeFlag = constants.sequence.TYPE_FLAG;
|
||||
var hasFlag = flags & constants.flags.VERIFY_SEQUENCE;
|
||||
var minHeight = -1;
|
||||
var minTime = -1;
|
||||
|
||||
@ -101,9 +101,9 @@ ChainBlock.prototype.isGenesis = function isGenesis() {
|
||||
|
||||
ChainBlock.prototype.ensureAncestors = function ensureAncestors(callback) {
|
||||
var majorityWindow = network.block.majorityWindow;
|
||||
var medianTimespan = constants.block.medianTimespan;
|
||||
var powDiffInterval = network.powDiffInterval;
|
||||
var allowMinDiff = network.powAllowMinDifficultyBlocks;
|
||||
var medianTimespan = constants.block.MEDIAN_TIMESPAN;
|
||||
var powDiffInterval = network.pow.diffInterval;
|
||||
var allowMinDiff = network.pow.allowMinDifficultyBlocks;
|
||||
var max = Math.max(majorityWindow, medianTimespan);
|
||||
if ((this.height + 1) % powDiffInterval === 0 || allowMinDiff)
|
||||
max = Math.max(max, powDiffInterval);
|
||||
@ -288,7 +288,7 @@ ChainBlock.prototype.getNext = function getNext(callback) {
|
||||
ChainBlock.prototype.getMedianTime = function getMedianTime(ancestors) {
|
||||
var entry = this;
|
||||
var median = [];
|
||||
var timeSpan = constants.block.medianTimespan;
|
||||
var timeSpan = constants.block.MEDIAN_TIMESPAN;
|
||||
var i;
|
||||
|
||||
if (!ancestors)
|
||||
@ -358,7 +358,7 @@ ChainBlock.prototype.isSuperMajority = function isSuperMajority(version, require
|
||||
ChainBlock.prototype.getMedianTimeAsync = function getMedianTimeAsync(callback) {
|
||||
var self = this;
|
||||
|
||||
return this.getAncestors(constants.block.medianTimespan, function(err, ancestors) {
|
||||
return this.getAncestors(constants.block.MEDIAN_TIMESPAN, function(err, ancestors) {
|
||||
if (err)
|
||||
return callback(err);
|
||||
|
||||
|
||||
@ -60,8 +60,8 @@ function ChainDB(chain, options) {
|
||||
// Need to cache up to the retarget interval
|
||||
// if we're going to be checking the damn
|
||||
// target all the time.
|
||||
if (network.powAllowMinDifficultyBlocks)
|
||||
this._cacheWindow = network.powDiffInterval + 1;
|
||||
if (network.pow.allowMinDifficultyBlocks)
|
||||
this._cacheWindow = network.pow.diffInterval + 1;
|
||||
else
|
||||
this._cacheWindow = network.block.majorityWindow + 1;
|
||||
|
||||
|
||||
@ -343,9 +343,9 @@ HDPrivateKey.prototype.derive = function derive(index, hardened) {
|
||||
if (cached)
|
||||
return cached;
|
||||
|
||||
hardened = index >= constants.hd.hardened ? true : hardened;
|
||||
if (index < constants.hd.hardened && hardened)
|
||||
index += constants.hd.hardened;
|
||||
hardened = index >= constants.hd.HARDENED ? true : hardened;
|
||||
if (index < constants.hd.HARDENED && hardened)
|
||||
index += constants.hd.HARDENED;
|
||||
|
||||
p = new BufferWriter();
|
||||
|
||||
@ -371,7 +371,7 @@ HDPrivateKey.prototype.derive = function derive(index, hardened) {
|
||||
|
||||
if (!this.fingerPrint) {
|
||||
this.fingerPrint = utils.ripesha(this.publicKey)
|
||||
.slice(0, constants.hd.parentFingerPrintSize);
|
||||
.slice(0, constants.hd.PARENT_FINGERPRINT_SIZE);
|
||||
}
|
||||
|
||||
child = new HDPrivateKey({
|
||||
@ -456,7 +456,7 @@ HDPrivateKey.prototype.derivePurpose45 = function derivePurpose45() {
|
||||
HDPrivateKey.prototype.isPurpose45 = function isPurpose45() {
|
||||
if (this.depth !== 1)
|
||||
return false;
|
||||
return this.childIndex === constants.hd.hardened + 45;
|
||||
return this.childIndex === constants.hd.HARDENED + 45;
|
||||
};
|
||||
|
||||
/**
|
||||
@ -465,7 +465,7 @@ HDPrivateKey.prototype.isPurpose45 = function isPurpose45() {
|
||||
*/
|
||||
|
||||
HDPrivateKey.prototype.isAccount44 = function isAccount44() {
|
||||
if (this.childIndex < constants.hd.hardened)
|
||||
if (this.childIndex < constants.hd.HARDENED)
|
||||
return false;
|
||||
return this.depth === 3;
|
||||
};
|
||||
@ -495,10 +495,10 @@ HDPrivateKey._getIndexes = function _getIndexes(path) {
|
||||
var indexes = [];
|
||||
var i, step, hardened, index;
|
||||
|
||||
if (~constants.hd.pathRoots.indexOf(path))
|
||||
if (~constants.hd.PATH_ROOTS.indexOf(path))
|
||||
return indexes;
|
||||
|
||||
if (!~constants.hd.pathRoots.indexOf(root))
|
||||
if (!~constants.hd.PATH_ROOTS.indexOf(root))
|
||||
return null;
|
||||
|
||||
for (i = 0; i < steps.length; i++) {
|
||||
@ -514,7 +514,7 @@ HDPrivateKey._getIndexes = function _getIndexes(path) {
|
||||
index = +step;
|
||||
|
||||
if (hardened)
|
||||
index += constants.hd.hardened;
|
||||
index += constants.hd.HARDENED;
|
||||
|
||||
indexes.push(index);
|
||||
}
|
||||
@ -538,9 +538,9 @@ HDPrivateKey.isValidPath = function isValidPath(path, hardened) {
|
||||
}
|
||||
|
||||
if (typeof path === 'number') {
|
||||
if (path < constants.hd.hardened && hardened)
|
||||
path += constants.hd.hardened;
|
||||
return path >= 0 && path < constants.hd.maxIndex;
|
||||
if (path < constants.hd.HARDENED && hardened)
|
||||
path += constants.hd.HARDENED;
|
||||
return path >= 0 && path < constants.hd.MAX_INDEX;
|
||||
}
|
||||
|
||||
return false;
|
||||
@ -579,8 +579,8 @@ HDPrivateKey._fromSeed = function _fromSeed(seed, networkType) {
|
||||
var data = seed.createSeed();
|
||||
var hash;
|
||||
|
||||
if (data.length < constants.hd.minEntropy
|
||||
|| data.length > constants.hd.maxEntropy) {
|
||||
if (data.length < constants.hd.MIN_ENTROPY
|
||||
|| data.length > constants.hd.MAX_ENTROPY) {
|
||||
throw new Error('Entropy not in range.');
|
||||
}
|
||||
|
||||
@ -965,7 +965,7 @@ HDPublicKey.prototype.derive = function derive(index, hardened) {
|
||||
if (cached)
|
||||
return cached;
|
||||
|
||||
if (index >= constants.hd.hardened || hardened)
|
||||
if (index >= constants.hd.HARDENED || hardened)
|
||||
throw new Error('Invalid index.');
|
||||
|
||||
if (index < 0)
|
||||
@ -986,7 +986,7 @@ HDPublicKey.prototype.derive = function derive(index, hardened) {
|
||||
|
||||
if (!this.fingerPrint) {
|
||||
this.fingerPrint = utils.ripesha(this.publicKey)
|
||||
.slice(0, constants.hd.parentFingerPrintSize);
|
||||
.slice(0, constants.hd.PARENT_FINGERPRINT_SIZE);
|
||||
}
|
||||
|
||||
child = new HDPublicKey({
|
||||
@ -1058,7 +1058,7 @@ HDPublicKey.isValidPath = function isValidPath(arg) {
|
||||
}
|
||||
|
||||
if (typeof arg === 'number')
|
||||
return arg >= 0 && arg < constants.hd.hardened;
|
||||
return arg >= 0 && arg < constants.hd.HARDENED;
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
@ -67,7 +67,7 @@ HTTPServer.prototype._init = function _init() {
|
||||
}
|
||||
|
||||
res.setHeader('X-Bcoin-Network', network.type);
|
||||
res.setHeader('X-Bcoin-Version', constants.userAgent);
|
||||
res.setHeader('X-Bcoin-Version', constants.USER_AGENT);
|
||||
|
||||
next();
|
||||
});
|
||||
@ -182,7 +182,7 @@ HTTPServer.prototype._init = function _init() {
|
||||
|
||||
this.get('/', function(req, res, next, send) {
|
||||
send(200, {
|
||||
version: constants.userAgent,
|
||||
version: constants.USER_AGENT,
|
||||
network: network.type
|
||||
});
|
||||
});
|
||||
@ -603,7 +603,7 @@ HTTPServer.prototype._initIO = function _initIO() {
|
||||
self.emit('websocket', socket);
|
||||
|
||||
socket.emit('version', {
|
||||
version: constants.userAgent,
|
||||
version: constants.USER_AGENT,
|
||||
network: network.type
|
||||
});
|
||||
});
|
||||
|
||||
@ -181,7 +181,7 @@ Input.prototype.isFinal = function isFinal() {
|
||||
*/
|
||||
|
||||
Input.prototype.isCoinbase = function isCoinbase() {
|
||||
return this.prevout.hash === constants.nullHash;
|
||||
return this.prevout.hash === constants.NULL_HASH;
|
||||
};
|
||||
|
||||
/**
|
||||
|
||||
@ -753,7 +753,7 @@ Mempool.prototype.verify = function verify(tx, callback) {
|
||||
0));
|
||||
}
|
||||
|
||||
if (tx.getSigops(true) > constants.tx.maxSigops) {
|
||||
if (tx.getSigops(true) > constants.tx.MAX_SIGOPS) {
|
||||
return callback(new VerifyError(tx,
|
||||
'nonstandard',
|
||||
'bad-txns-too-many-sigops',
|
||||
@ -1292,10 +1292,10 @@ Mempool.prototype.checkLocks = function checkLocks(tx, flags, callback) {
|
||||
var tip = this.chain.tip;
|
||||
|
||||
var index = new bcoin.chainblock(this.chain, {
|
||||
hash: utils.toHex(constants.zeroHash),
|
||||
hash: utils.toHex(constants.ZERO_HASH),
|
||||
version: tip.version,
|
||||
prevBlock: tip.hash,
|
||||
merkleRoot: utils.toHex(constants.zeroHash),
|
||||
merkleRoot: utils.toHex(constants.ZERO_HASH),
|
||||
ts: utils.now(),
|
||||
bits: 0,
|
||||
nonce: 0,
|
||||
|
||||
@ -336,7 +336,7 @@ function MinerBlock(options) {
|
||||
|
||||
this.coinbase.addInput({
|
||||
prevout: {
|
||||
hash: constants.nullHash,
|
||||
hash: constants.NULL_HASH,
|
||||
index: 0xffffffff
|
||||
},
|
||||
coin: null,
|
||||
@ -369,7 +369,7 @@ function MinerBlock(options) {
|
||||
this.block = new bcoin.block({
|
||||
version: options.version,
|
||||
prevBlock: this.tip.hash,
|
||||
merkleRoot: constants.nullHash,
|
||||
merkleRoot: constants.NULL_HASH,
|
||||
ts: Math.max(utils.now(), this.tip.ts + 1),
|
||||
bits: options.target,
|
||||
nonce: 0,
|
||||
@ -444,7 +444,7 @@ MinerBlock.prototype.addTX = function addTX(tx) {
|
||||
var size = this.block.getVirtualSize(true) + tx.getVirtualSize();
|
||||
|
||||
// Deliver me from the block size debate, please
|
||||
if (size > constants.block.maxSize)
|
||||
if (size > constants.block.MAX_SIZE)
|
||||
return false;
|
||||
|
||||
if (this.block.hasTX(tx))
|
||||
|
||||
@ -137,8 +137,8 @@ MTX.prototype.witnessHash = function witnessHash(enc) {
|
||||
|
||||
if (this.isCoinbase()) {
|
||||
return enc === 'hex'
|
||||
? utils.toHex(constants.zeroHash)
|
||||
: utils.slice(constants.zeroHash);
|
||||
? utils.toHex(constants.ZERO_HASH)
|
||||
: utils.slice(constants.ZERO_HASH);
|
||||
}
|
||||
|
||||
if (!this.hasWitness())
|
||||
@ -459,7 +459,7 @@ MTX.prototype.createSignature = function createSignature(index, prev, key, type,
|
||||
type = 'all';
|
||||
|
||||
if (typeof type === 'string')
|
||||
type = constants.hashType[type];
|
||||
type = constants.hashType[type.toUpperCase()];
|
||||
|
||||
// Get the hash of the current tx, minus the other
|
||||
// inputs, plus the sighash type.
|
||||
@ -1109,7 +1109,7 @@ MTX.prototype.selectCoins = function selectCoins(coins, options) {
|
||||
continue;
|
||||
|
||||
if (network.height !== -1 && coin.coinbase) {
|
||||
if (network.height + 1 < coin.height + constants.tx.coinbaseMaturity)
|
||||
if (network.height + 1 < coin.height + constants.tx.COINBASE_MATURITY)
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -1135,7 +1135,7 @@ MTX.prototype.selectCoins = function selectCoins(coins, options) {
|
||||
// Transfer `total` funds maximum.
|
||||
addCoins();
|
||||
} else {
|
||||
fee = new bn(constants.tx.minFee);
|
||||
fee = new bn(constants.tx.MIN_FEE);
|
||||
|
||||
// Transfer `total` funds maximum.
|
||||
addCoins();
|
||||
@ -1146,7 +1146,7 @@ MTX.prototype.selectCoins = function selectCoins(coins, options) {
|
||||
address: options.changeAddress,
|
||||
// In case we don't have a change address,
|
||||
// use a fake p2pkh output to gauge size.
|
||||
keyHash: constants.zeroHash.slice(0, 20),
|
||||
keyHash: constants.ZERO_HASH.slice(0, 20),
|
||||
value: new bn(0)
|
||||
});
|
||||
|
||||
@ -1187,7 +1187,7 @@ MTX.prototype.selectCoins = function selectCoins(coins, options) {
|
||||
|
||||
// Attempt to subtract fee.
|
||||
if (options.subtractFee != null) {
|
||||
minValue = fee.addn(constants.tx.dustThreshold);
|
||||
minValue = fee.addn(constants.tx.DUST_THRESHOLD);
|
||||
if (typeof options.subtractFee === 'number') {
|
||||
i = options.subtractFee;
|
||||
|
||||
@ -1241,7 +1241,7 @@ MTX.prototype.fill = function fill(coins, options) {
|
||||
for (i = 0; i < result.coins.length; i++)
|
||||
this.addInput(result.coins[i]);
|
||||
|
||||
if (result.change.cmpn(constants.tx.dustThreshold) < 0) {
|
||||
if (result.change.cmpn(constants.tx.DUST_THRESHOLD) < 0) {
|
||||
// Do nothing. Change is added to fee.
|
||||
assert(this.getFee().cmp(result.fee.add(result.change)) === 0);
|
||||
this.changeIndex = -1;
|
||||
|
||||
@ -318,20 +318,20 @@ Peer.prototype.broadcast = function broadcast(items) {
|
||||
var entry, packetType;
|
||||
|
||||
if (typeof type === 'string')
|
||||
type = constants.inv[type];
|
||||
type = constants.inv[type.toUpperCase()];
|
||||
|
||||
// INV does not set the witness
|
||||
// mask (only GETDATA does this).
|
||||
type &= ~constants.invWitnessMask;
|
||||
type &= ~constants.WITNESS_MASK;
|
||||
|
||||
if (type === constants.inv.block)
|
||||
if (type === constants.inv.BLOCK)
|
||||
packetType = 'block';
|
||||
else if (type === constants.inv.tx)
|
||||
else if (type === constants.inv.TX)
|
||||
packetType = 'tx';
|
||||
else
|
||||
assert(false, 'Bad type.');
|
||||
|
||||
if (self.filter && type === constants.inv.tx) {
|
||||
if (self.filter && type === constants.inv.TX) {
|
||||
if (!item.isWatched(self.filter))
|
||||
return;
|
||||
}
|
||||
@ -395,7 +395,7 @@ Peer.prototype.updateWatch = function updateWatch() {
|
||||
filter: this.bloom.toBuffer(),
|
||||
n: this.bloom.n,
|
||||
tweak: this.bloom.tweak,
|
||||
update: 'none'
|
||||
update: constants.filterFlags.NONE
|
||||
}));
|
||||
}
|
||||
};
|
||||
@ -924,7 +924,7 @@ Peer.prototype._handleGetBlocks = function _handleGetBlocks(payload) {
|
||||
if (!hash)
|
||||
return done();
|
||||
|
||||
blocks.push({ type: constants.inv.block, hash: hash });
|
||||
blocks.push({ type: constants.inv.BLOCK, hash: hash });
|
||||
|
||||
if (hash === payload.stop)
|
||||
return done();
|
||||
@ -941,7 +941,7 @@ Peer.prototype._handleGetBlocks = function _handleGetBlocks(payload) {
|
||||
};
|
||||
|
||||
Peer.prototype._handleVersion = function handleVersion(payload) {
|
||||
if (payload.version < constants.minVersion) {
|
||||
if (payload.version < constants.MIN_VERSION) {
|
||||
this._error('Peer doesn\'t support required protocol version.');
|
||||
this.setMisbehavior(100);
|
||||
return;
|
||||
@ -1011,7 +1011,7 @@ Peer.prototype._handleMempool = function _handleMempool() {
|
||||
return self.emit('error', err);
|
||||
|
||||
for (i = 0; i < hashes.length; i++)
|
||||
items.push({ type: constants.inv.tx, hash: hashes[i] });
|
||||
items.push({ type: constants.inv.TX, hash: hashes[i] });
|
||||
|
||||
bcoin.debug('Sending mempool snapshot to %s.', self.host);
|
||||
|
||||
@ -1033,7 +1033,7 @@ Peer.prototype._handleGetData = function handleGetData(items) {
|
||||
|
||||
hash = utils.toHex(item.hash);
|
||||
entry = this._broadcast.map[hash];
|
||||
isWitness = item.type & constants.invWitnessMask;
|
||||
isWitness = item.type & constants.WITNESS_MASK;
|
||||
value = null;
|
||||
|
||||
if (!entry) {
|
||||
@ -1041,7 +1041,7 @@ Peer.prototype._handleGetData = function handleGetData(items) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((item.type & ~constants.invWitnessMask) !== entry.type) {
|
||||
if ((item.type & ~constants.WITNESS_MASK) !== entry.type) {
|
||||
bcoin.debug(
|
||||
'Peer %s requested an existing item with the wrong type.',
|
||||
this.host);
|
||||
@ -1067,14 +1067,14 @@ Peer.prototype._handleGetData = function handleGetData(items) {
|
||||
return;
|
||||
|
||||
utils.forEachSerial(check, function(item, next) {
|
||||
var isWitness = item.type & constants.invWitnessMask;
|
||||
var type = item.type & ~constants.invWitnessMask;
|
||||
var isWitness = item.type & constants.WITNESS_MASK;
|
||||
var type = item.type & ~constants.WITNESS_MASK;
|
||||
var hash = utils.toHex(item.hash);
|
||||
var i, tx, data;
|
||||
|
||||
if (type === constants.inv.tx) {
|
||||
if (type === constants.inv.TX) {
|
||||
if (!self.mempool) {
|
||||
notfound.push({ type: constants.inv.tx, hash: hash });
|
||||
notfound.push({ type: constants.inv.TX, hash: hash });
|
||||
return next();
|
||||
}
|
||||
return self.mempool.getTX(hash, function(err, tx) {
|
||||
@ -1082,7 +1082,7 @@ Peer.prototype._handleGetData = function handleGetData(items) {
|
||||
return next(err);
|
||||
|
||||
if (!tx) {
|
||||
notfound.push({ type: constants.inv.tx, hash: hash });
|
||||
notfound.push({ type: constants.inv.TX, hash: hash });
|
||||
return next();
|
||||
}
|
||||
|
||||
@ -1097,13 +1097,13 @@ Peer.prototype._handleGetData = function handleGetData(items) {
|
||||
});
|
||||
}
|
||||
|
||||
if (type === constants.inv.block) {
|
||||
if (type === constants.inv.BLOCK) {
|
||||
if (self.chain.db.options.spv) {
|
||||
notfound.push({ type: constants.inv.block, hash: hash });
|
||||
notfound.push({ type: constants.inv.BLOCK, hash: hash });
|
||||
return next();
|
||||
}
|
||||
if (self.chain.db.options.prune) {
|
||||
notfound.push({ type: constants.inv.block, hash: hash });
|
||||
notfound.push({ type: constants.inv.BLOCK, hash: hash });
|
||||
return;
|
||||
}
|
||||
return self.chain.db.getBlock(hash, function(err, block) {
|
||||
@ -1111,7 +1111,7 @@ Peer.prototype._handleGetData = function handleGetData(items) {
|
||||
return next(err);
|
||||
|
||||
if (!block) {
|
||||
notfound.push({ type: constants.inv.block, hash: hash });
|
||||
notfound.push({ type: constants.inv.BLOCK, hash: hash });
|
||||
return next();
|
||||
}
|
||||
|
||||
@ -1124,7 +1124,7 @@ Peer.prototype._handleGetData = function handleGetData(items) {
|
||||
|
||||
if (hash === self.hashContinue) {
|
||||
self._write(self.framer.inv([{
|
||||
type: constants.inv.block,
|
||||
type: constants.inv.BLOCK,
|
||||
hash: self.chain.tip.hash
|
||||
}]));
|
||||
self.hashContinue = null;
|
||||
@ -1134,13 +1134,13 @@ Peer.prototype._handleGetData = function handleGetData(items) {
|
||||
});
|
||||
}
|
||||
|
||||
if (type === constants.inv.filteredblock) {
|
||||
if (type === constants.inv.FILTERED_BLOCK) {
|
||||
if (self.chain.db.options.spv) {
|
||||
notfound.push({ type: constants.inv.block, hash: hash });
|
||||
notfound.push({ type: constants.inv.BLOCK, hash: hash });
|
||||
return next();
|
||||
}
|
||||
if (self.chain.db.options.prune) {
|
||||
notfound.push({ type: constants.inv.block, hash: hash });
|
||||
notfound.push({ type: constants.inv.BLOCK, hash: hash });
|
||||
return;
|
||||
}
|
||||
return self.chain.db.getBlock(hash, function(err, block) {
|
||||
@ -1148,7 +1148,7 @@ Peer.prototype._handleGetData = function handleGetData(items) {
|
||||
return next(err);
|
||||
|
||||
if (!block) {
|
||||
notfound.push({ type: constants.inv.block, hash: hash });
|
||||
notfound.push({ type: constants.inv.BLOCK, hash: hash });
|
||||
return next();
|
||||
}
|
||||
|
||||
@ -1169,7 +1169,7 @@ Peer.prototype._handleGetData = function handleGetData(items) {
|
||||
|
||||
if (hash === self.hashContinue) {
|
||||
self._write(self.framer.inv([{
|
||||
type: constants.inv.block,
|
||||
type: constants.inv.BLOCK,
|
||||
hash: self.chain.tip.hash
|
||||
}]));
|
||||
self.hashContinue = null;
|
||||
@ -1295,9 +1295,9 @@ Peer.prototype._handleInv = function handleInv(items) {
|
||||
|
||||
for (i = 0; i < items.length; i++) {
|
||||
item = items[i];
|
||||
if (item.type === constants.inv.tx)
|
||||
if (item.type === constants.inv.TX)
|
||||
txs.push(item.hash);
|
||||
else if (item.type === constants.inv.block)
|
||||
else if (item.type === constants.inv.BLOCK)
|
||||
blocks.push(item.hash);
|
||||
}
|
||||
|
||||
|
||||
@ -151,19 +151,19 @@ function Pool(options) {
|
||||
versionHeight: 0,
|
||||
bestHash: null,
|
||||
type: !options.spv
|
||||
? constants.inv.block
|
||||
: constants.inv.filteredblock
|
||||
? constants.inv.BLOCK
|
||||
: constants.inv.FILTERED_BLOCK
|
||||
};
|
||||
|
||||
this.tx = {
|
||||
state: {},
|
||||
count: 0,
|
||||
type: constants.inv.tx
|
||||
type: constants.inv.TX
|
||||
};
|
||||
|
||||
if (this.options.witness) {
|
||||
this.block.type |= constants.invWitnessMask;
|
||||
this.tx.type |= constants.invWitnessMask;
|
||||
this.block.type |= constants.WITNESS_MASK;
|
||||
this.tx.type |= constants.WITNESS_MASK;
|
||||
}
|
||||
|
||||
this.request = {
|
||||
@ -2162,7 +2162,7 @@ Pool.prototype.removeSeed = function removeSeed(seed) {
|
||||
Pool.prototype.setMisbehavior = function setMisbehavior(peer, score) {
|
||||
peer.banScore += score;
|
||||
|
||||
if (peer.banScore >= constants.banScore) {
|
||||
if (peer.banScore >= constants.BAN_SCORE) {
|
||||
this.peers.misbehaving[peer.host] = utils.now();
|
||||
bcoin.debug('Ban threshold exceeded for %s', peer.host);
|
||||
peer.destroy();
|
||||
@ -2187,7 +2187,7 @@ Pool.prototype.isMisbehaving = function isMisbehaving(host) {
|
||||
time = this.peers.misbehaving[host];
|
||||
|
||||
if (time) {
|
||||
if (utils.now() > time + constants.banTime) {
|
||||
if (utils.now() > time + constants.BAN_TIME) {
|
||||
delete this.peers.misbehaving[host];
|
||||
peer = this.getPeer(host);
|
||||
if (peer)
|
||||
|
||||
@ -18,7 +18,7 @@ var utils = require('../utils');
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.minVersion = 70001;
|
||||
exports.MIN_VERSION = 70001;
|
||||
|
||||
/**
|
||||
* BCoin's protocol version.
|
||||
@ -26,7 +26,7 @@ exports.minVersion = 70001;
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.version = 70012;
|
||||
exports.VERSION = 70012;
|
||||
|
||||
/**
|
||||
* Max message size (~4mb with segwit, formerly 2mb)
|
||||
@ -34,7 +34,7 @@ exports.version = 70012;
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.maxMessage = 4 * 1000 * 1000;
|
||||
exports.MAX_MESSAGE = 4 * 1000 * 1000;
|
||||
|
||||
/**
|
||||
* Service bits.
|
||||
@ -43,10 +43,10 @@ exports.maxMessage = 4 * 1000 * 1000;
|
||||
*/
|
||||
|
||||
exports.services = {
|
||||
network: (1 << 0),
|
||||
getutxo: (1 << 1),
|
||||
bloom: (1 << 2),
|
||||
witness: (1 << 3)
|
||||
NETWORK: (1 << 0),
|
||||
GETUTXO: (1 << 1),
|
||||
BLOOM: (1 << 2),
|
||||
WITNESS: (1 << 3)
|
||||
};
|
||||
|
||||
/**
|
||||
@ -55,8 +55,7 @@ exports.services = {
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.localServices = exports.services.network
|
||||
| exports.services.witness;
|
||||
exports.LOCAL_SERVICES = exports.services.NETWORK | exports.services.WITNESS;
|
||||
|
||||
/**
|
||||
* Inv types.
|
||||
@ -65,13 +64,13 @@ exports.localServices = exports.services.network
|
||||
*/
|
||||
|
||||
exports.inv = {
|
||||
error: 0,
|
||||
tx: 1,
|
||||
block: 2,
|
||||
filteredblock: 3,
|
||||
witnesstx: 1 | (1 << 30),
|
||||
witnessblock: 2 | (1 << 30),
|
||||
witnessfilteredblock: 3 | (1 << 30)
|
||||
ERROR: 0,
|
||||
TX: 1,
|
||||
BLOCK: 2,
|
||||
FILTERED_BLOCK: 3,
|
||||
WITNESS_TX: 1 | (1 << 30),
|
||||
WITNESS_BLOCK: 2 | (1 << 30),
|
||||
WITNESS_FILTERED_BLOCK: 3 | (1 << 30)
|
||||
};
|
||||
|
||||
/**
|
||||
@ -93,7 +92,7 @@ exports.invByVal = utils.revMap(exports.inv);
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.invWitnessMask = 1 << 30;
|
||||
exports.WITNESS_MASK = 1 << 30;
|
||||
|
||||
/**
|
||||
* Bloom filter update flags.
|
||||
@ -102,9 +101,9 @@ exports.invWitnessMask = 1 << 30;
|
||||
*/
|
||||
|
||||
exports.filterFlags = {
|
||||
none: 0,
|
||||
all: 1,
|
||||
pubkeyOnly: 2
|
||||
NONE: 0,
|
||||
ALL: 1,
|
||||
PUBKEY_ONLY: 2
|
||||
};
|
||||
|
||||
/**
|
||||
@ -268,7 +267,7 @@ exports.opcodesByVal = utils.revMap(exports.opcodes);
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.coin = new bn(10000000).muln(10);
|
||||
exports.COIN = new bn(10000000).muln(10);
|
||||
|
||||
/**
|
||||
* One bitcoin / 100.
|
||||
@ -276,7 +275,7 @@ exports.coin = new bn(10000000).muln(10);
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.cent = new bn(1000000);
|
||||
exports.CENT = new bn(1000000);
|
||||
|
||||
/**
|
||||
* Maximum amount of money in satoshis (1btc * 21million)
|
||||
@ -284,7 +283,7 @@ exports.cent = new bn(1000000);
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.maxMoney = new bn(21000000).mul(exports.coin);
|
||||
exports.MAX_MONEY = new bn(21000000).mul(exports.COIN);
|
||||
|
||||
/**
|
||||
* Sighash Types.
|
||||
@ -293,10 +292,10 @@ exports.maxMoney = new bn(21000000).mul(exports.coin);
|
||||
*/
|
||||
|
||||
exports.hashType = {
|
||||
all: 1,
|
||||
none: 2,
|
||||
single: 3,
|
||||
anyonecanpay: 0x80
|
||||
ALL: 1,
|
||||
NONE: 2,
|
||||
SINGLE: 3,
|
||||
ANYONECANPAY: 0x80
|
||||
};
|
||||
|
||||
/**
|
||||
@ -313,12 +312,12 @@ exports.hashTypeByVal = utils.revMap(exports.hashType);
|
||||
*/
|
||||
|
||||
exports.block = {
|
||||
maxSize: 1000000,
|
||||
maxSigops: 1000000 / 50,
|
||||
maxOrphanTx: 1000000 / 100,
|
||||
medianTimespan: 11,
|
||||
bip16time: 1333238400,
|
||||
sighashLimit: 1300000000
|
||||
MAX_SIZE: 1000000,
|
||||
MAX_SIGOPS: 1000000 / 50,
|
||||
MAX_ORPHAN_TX: 1000000 / 100,
|
||||
MEDIAN_TIMESPAN: 11,
|
||||
BIP16_TIME: 1333238400,
|
||||
SIGHASH_LIMIT: 1300000000
|
||||
};
|
||||
|
||||
/**
|
||||
@ -328,16 +327,16 @@ exports.block = {
|
||||
*/
|
||||
|
||||
exports.tx = {
|
||||
version: 2,
|
||||
maxSize: 100000,
|
||||
minFee: 10000,
|
||||
bareMultisig: true,
|
||||
freeThreshold: exports.coin.muln(144).divn(250),
|
||||
maxSigops: exports.block.maxSigops / 5,
|
||||
coinbaseMaturity: 100
|
||||
MAX_VERSION: 2,
|
||||
MAX_SIZE: 100000,
|
||||
MIN_FEE: 10000,
|
||||
BARE_MULTISIG: true,
|
||||
FREE_THRESHOLD: exports.COIN.muln(144).divn(250),
|
||||
MAX_SIGOPS: exports.block.MAX_SIGOPS / 5,
|
||||
COINBASE_MATURITY: 100
|
||||
};
|
||||
|
||||
exports.tx.dustThreshold = 182 * exports.tx.minFee / 1000 * 3;
|
||||
exports.tx.DUST_THRESHOLD = 182 * exports.tx.MIN_FEE / 1000 * 3;
|
||||
|
||||
/**
|
||||
* Script-related constants.
|
||||
@ -346,14 +345,14 @@ exports.tx.dustThreshold = 182 * exports.tx.minFee / 1000 * 3;
|
||||
*/
|
||||
|
||||
exports.script = {
|
||||
maxSize: 10000,
|
||||
maxStack: 1000,
|
||||
maxPush: 520,
|
||||
maxOps: 201,
|
||||
maxPubkeysPerMultisig: 20,
|
||||
maxScripthashSigops: 15,
|
||||
maxOpReturnBytes: 83,
|
||||
maxOpReturn: 80
|
||||
MAX_SIZE: 10000,
|
||||
MAX_STACK: 1000,
|
||||
MAX_PUSH: 520,
|
||||
MAX_OPS: 201,
|
||||
MAX_MULTISIG_PUBKEYS: 20,
|
||||
MAX_SCRIPTHASH_SIGOPS: 15,
|
||||
MAX_OP_RETURN_BYTES: 83,
|
||||
MAX_OP_RETURN: 80
|
||||
};
|
||||
|
||||
/**
|
||||
@ -364,19 +363,19 @@ exports.script = {
|
||||
*/
|
||||
|
||||
exports.reject = {
|
||||
malformed: 0x01,
|
||||
invalid: 0x10,
|
||||
obsolete: 0x11,
|
||||
duplicate: 0x12,
|
||||
nonstandard: 0x40,
|
||||
dust: 0x41,
|
||||
insufficientfee: 0x42,
|
||||
checkpoint: 0x43,
|
||||
MALFORMED: 0x01,
|
||||
INVALID: 0x10,
|
||||
OBSOLETE: 0x11,
|
||||
DUPLICATE: 0x12,
|
||||
NONSTANDARD: 0x40,
|
||||
DUST: 0x41,
|
||||
INSUFFICIENTFEE: 0x42,
|
||||
CHECKPOINT: 0x43,
|
||||
// Internal codes (NOT FOR USE ON NETWORK)
|
||||
internal: 0x100,
|
||||
highfee: 0x100,
|
||||
alreadyknown: 0x101,
|
||||
conflict: 0x102
|
||||
INTERNAL: 0x100,
|
||||
HIGHFEE: 0x100,
|
||||
ALREADYKNOWN: 0x101,
|
||||
CONFLICT: 0x102
|
||||
};
|
||||
|
||||
/**
|
||||
@ -393,12 +392,12 @@ exports.rejectByVal = utils.revMap(exports.reject);
|
||||
*/
|
||||
|
||||
exports.hd = {
|
||||
hardened: 0x80000000,
|
||||
maxIndex: 2 * 0x80000000,
|
||||
minEntropy: 128 / 8,
|
||||
maxEntropy: 512 / 8,
|
||||
parentFingerPrintSize: 4,
|
||||
pathRoots: ['m', 'M', 'm\'', 'M\'']
|
||||
HARDENED: 0x80000000,
|
||||
MAX_INDEX: 2 * 0x80000000,
|
||||
MIN_ENTROPY: 128 / 8,
|
||||
MAX_ENTROPY: 512 / 8,
|
||||
PARENT_FINGERPRINT_SIZE: 4,
|
||||
PATH_ROOTS: ['m', 'M', 'm\'', 'M\'']
|
||||
};
|
||||
|
||||
/**
|
||||
@ -409,35 +408,37 @@ exports.hd = {
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.locktimeThreshold = 500000000;
|
||||
exports.LOCKTIME_THRESHOLD = 500000000;
|
||||
|
||||
exports.sequence = {};
|
||||
|
||||
/**
|
||||
* Highest nSequence bit (disables sequence locktimes).
|
||||
* @const {Number}
|
||||
*/
|
||||
|
||||
exports.sequenceLocktimeDisableFlag = (1 << 31) >>> 0;
|
||||
exports.sequence.DISABLE_FLAG = (1 << 31) >>> 0;
|
||||
|
||||
/**
|
||||
* @const {Number}
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.sequenceLocktimeTypeFlag = 1 << 22;
|
||||
exports.sequence.TYPE_FLAG = 1 << 22;
|
||||
|
||||
/**
|
||||
* @const {Number}
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.sequenceLocktimeGranularity = 9;
|
||||
exports.sequence.GRANULARITY = 9;
|
||||
|
||||
/**
|
||||
* @const {Number}
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.sequenceLocktimeMask = 0x0000ffff;
|
||||
exports.sequence.MASK = 0x0000ffff;
|
||||
|
||||
/**
|
||||
* A hash of all zeroes with a `1` at the
|
||||
@ -446,7 +447,7 @@ exports.sequenceLocktimeMask = 0x0000ffff;
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.oneHash = new Buffer(
|
||||
exports.ONE_HASH = new Buffer(
|
||||
'0000000000000000000000000000000000000000000000000000000000000001',
|
||||
'hex'
|
||||
);
|
||||
@ -457,7 +458,7 @@ exports.oneHash = new Buffer(
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.zeroHash = new Buffer(
|
||||
exports.ZERO_HASH = new Buffer(
|
||||
'0000000000000000000000000000000000000000000000000000000000000000',
|
||||
'hex'
|
||||
);
|
||||
@ -468,7 +469,7 @@ exports.zeroHash = new Buffer(
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.nullHash =
|
||||
exports.NULL_HASH =
|
||||
'0000000000000000000000000000000000000000000000000000000000000000';
|
||||
|
||||
/**
|
||||
@ -477,7 +478,7 @@ exports.nullHash =
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.userVersion = require('../../../package.json').version;
|
||||
exports.USER_VERSION = require('../../../package.json').version;
|
||||
|
||||
/**
|
||||
* BCoin user agent: `/bcoin:{version}/`.
|
||||
@ -485,10 +486,23 @@ exports.userVersion = require('../../../package.json').version;
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.userAgent = '/bcoin:' + exports.userVersion + '/';
|
||||
exports.USER_AGENT = '/bcoin:' + exports.USER_VERSION + '/';
|
||||
|
||||
exports.banTime = 24 * 60 * 60;
|
||||
exports.banScore = 100;
|
||||
/**
|
||||
* Amount of time to ban misbheaving peers.
|
||||
* @const {Number}
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.BAN_TIME = 24 * 60 * 60;
|
||||
|
||||
/**
|
||||
* Ban score threshold before ban is placed in effect.
|
||||
* @const {Number}
|
||||
* @default
|
||||
*/
|
||||
|
||||
exports.BAN_SCORE = 100;
|
||||
|
||||
/**
|
||||
* Script and locktime flags. See {@link VerifyFlags}.
|
||||
|
||||
@ -19,7 +19,7 @@ var DUMMY = new Buffer([]);
|
||||
* @exports Framer
|
||||
* @constructor
|
||||
* @param {Object} options
|
||||
* @param {String} options.userAgent - User agent string.
|
||||
* @param {String} options.USER_AGENT - User agent string.
|
||||
* @property {Buffer} agent
|
||||
*/
|
||||
|
||||
@ -31,7 +31,7 @@ function Framer(options) {
|
||||
|
||||
this.options = options;
|
||||
|
||||
this.agent = new Buffer(options.userAgent || constants.userAgent, 'ascii');
|
||||
this.agent = new Buffer(options.USER_AGENT || constants.USER_AGENT, 'ascii');
|
||||
}
|
||||
|
||||
/**
|
||||
@ -427,7 +427,7 @@ Framer.address = function address(data, full, writer) {
|
||||
|
||||
Framer.version = function version(options, writer) {
|
||||
var p = new BufferWriter(writer);
|
||||
var agent = options.agent || constants.userAgent;
|
||||
var agent = options.agent || constants.USER_AGENT;
|
||||
var remote = options.remote || {};
|
||||
var local = options.local || {};
|
||||
|
||||
@ -435,10 +435,10 @@ Framer.version = function version(options, writer) {
|
||||
agent = new Buffer(agent, 'ascii');
|
||||
|
||||
if (local.services == null)
|
||||
local.services = constants.localServices;
|
||||
local.services = constants.LOCAL_SERVICES;
|
||||
|
||||
p.write32(constants.version);
|
||||
p.writeU64(constants.localServices);
|
||||
p.write32(constants.VERSION);
|
||||
p.writeU64(constants.LOCAL_SERVICES);
|
||||
p.write64(utils.now());
|
||||
Framer.address(remote, false, p);
|
||||
Framer.address(local, false, p);
|
||||
@ -474,7 +474,7 @@ Framer._inv = function _inv(items, writer) {
|
||||
for (i = 0; i < items.length; i++) {
|
||||
type = items[i].type;
|
||||
if (typeof type === 'string')
|
||||
type = constants.inv[items[i].type];
|
||||
type = constants.inv[items[i].type.toUpperCase()];
|
||||
assert(constants.invByVal[type] != null);
|
||||
p.writeU32(type);
|
||||
p.writeHash(items[i].hash);
|
||||
@ -564,7 +564,7 @@ Framer.filterLoad = function filterLoad(data, writer) {
|
||||
var update = data.update;
|
||||
|
||||
if (typeof update === 'string')
|
||||
update = constants.filterFlags[update];
|
||||
update = constants.filterFlags[update.toUpperCase()];
|
||||
|
||||
assert(update != null, 'Bad filter flag.');
|
||||
|
||||
@ -608,7 +608,7 @@ Framer._getBlocks = function _getBlocks(data, writer, headers) {
|
||||
var p, i;
|
||||
|
||||
if (!version)
|
||||
version = constants.version;
|
||||
version = constants.VERSION;
|
||||
|
||||
if (!locator) {
|
||||
if (headers)
|
||||
@ -618,7 +618,7 @@ Framer._getBlocks = function _getBlocks(data, writer, headers) {
|
||||
}
|
||||
|
||||
if (!stop)
|
||||
stop = constants.zeroHash;
|
||||
stop = constants.ZERO_HASH;
|
||||
|
||||
p = new BufferWriter(writer);
|
||||
|
||||
@ -1038,10 +1038,16 @@ Framer.blockHeaders = function blockHeaders(block, writer) {
|
||||
|
||||
Framer.reject = function reject(details, writer) {
|
||||
var p = new BufferWriter(writer);
|
||||
var ccode = constants.reject[details.ccode] || constants.reject.invalid;
|
||||
var ccode = details.ccode;
|
||||
|
||||
if (ccode >= constants.reject.internal)
|
||||
ccode = constants.reject.invalid;
|
||||
if (typeof ccode === 'string')
|
||||
ccode = constants.reject[ccode.toUpperCase()]
|
||||
|
||||
if (!ccode)
|
||||
ccode = constants.reject.INVALID;
|
||||
|
||||
if (ccode >= constants.reject.INTERNAL)
|
||||
ccode = constants.reject.INVALID;
|
||||
|
||||
p.writeVarString(details.message || '', 'ascii');
|
||||
p.writeU8(ccode);
|
||||
|
||||
@ -210,12 +210,14 @@ main.genesis = {
|
||||
|
||||
main.magic = 0xd9b4bef9;
|
||||
|
||||
main.pow = {};
|
||||
|
||||
/**
|
||||
* Default target.
|
||||
* @const {Buffer}
|
||||
*/
|
||||
|
||||
main.powLimit = new bn(
|
||||
main.pow.limit = new bn(
|
||||
'00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
|
||||
'hex'
|
||||
);
|
||||
@ -226,7 +228,7 @@ main.powLimit = new bn(
|
||||
* @default
|
||||
*/
|
||||
|
||||
main.powTargetTimespan = 14 * 24 * 60 * 60; // two weeks
|
||||
main.pow.targetTimespan = 14 * 24 * 60 * 60; // two weeks
|
||||
|
||||
/**
|
||||
* Average block time.
|
||||
@ -234,7 +236,7 @@ main.powTargetTimespan = 14 * 24 * 60 * 60; // two weeks
|
||||
* @default
|
||||
*/
|
||||
|
||||
main.powTargetSpacing = 10 * 60;
|
||||
main.pow.targetSpacing = 10 * 60;
|
||||
|
||||
/**
|
||||
* Retarget interval in blocks.
|
||||
@ -242,21 +244,21 @@ main.powTargetSpacing = 10 * 60;
|
||||
* @default
|
||||
*/
|
||||
|
||||
main.powDiffInterval = main.powTargetTimespan / main.powTargetSpacing | 0;
|
||||
main.pow.diffInterval = main.pow.targetTimespan / main.pow.targetSpacing | 0;
|
||||
|
||||
/**
|
||||
* @const {Boolean}
|
||||
* @default
|
||||
*/
|
||||
|
||||
main.powAllowMinDifficultyBlocks = false;
|
||||
main.pow.allowMinDifficultyBlocks = false;
|
||||
|
||||
/**
|
||||
* @const {Boolean}
|
||||
* @default
|
||||
*/
|
||||
|
||||
main.powNoRetargeting = false;
|
||||
main.pow.noRetargeting = false;
|
||||
|
||||
/**
|
||||
* Block constants.
|
||||
@ -410,15 +412,17 @@ testnet.genesis = {
|
||||
|
||||
testnet.magic = 0x0709110b;
|
||||
|
||||
testnet.powLimit = new bn(
|
||||
testnet.pow = {};
|
||||
|
||||
testnet.pow.limit = new bn(
|
||||
'00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
|
||||
'hex'
|
||||
);
|
||||
testnet.powTargetTimespan = 14 * 24 * 60 * 60; // two weeks
|
||||
testnet.powTargetSpacing = 10 * 60;
|
||||
testnet.powDiffInterval = testnet.powTargetTimespan / testnet.powTargetSpacing | 0;
|
||||
testnet.powAllowMinDifficultyBlocks = true;
|
||||
testnet.powNoRetargeting = false;
|
||||
testnet.pow.targetTimespan = 14 * 24 * 60 * 60; // two weeks
|
||||
testnet.pow.targetSpacing = 10 * 60;
|
||||
testnet.pow.diffInterval = testnet.pow.targetTimespan / testnet.pow.targetSpacing | 0;
|
||||
testnet.pow.allowMinDifficultyBlocks = true;
|
||||
testnet.pow.noRetargeting = false;
|
||||
|
||||
testnet.block = {
|
||||
majorityEnforceUpgrade: 51,
|
||||
@ -506,15 +510,17 @@ regtest.genesis = {
|
||||
|
||||
regtest.magic = 0xdab5bffa;
|
||||
|
||||
regtest.powLimit = new bn(
|
||||
regtest.pow = {};
|
||||
|
||||
regtest.pow.limit = new bn(
|
||||
'7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
|
||||
'hex'
|
||||
);
|
||||
regtest.powTargetTimespan = 14 * 24 * 60 * 60; // two weeks
|
||||
regtest.powTargetSpacing = 10 * 60;
|
||||
regtest.powDiffInterval = regtest.powTargetTimespan / regtest.powTargetSpacing | 0;
|
||||
regtest.powAllowMinDifficultyBlocks = true;
|
||||
regtest.powNoRetargeting = true;
|
||||
regtest.pow.targetTimespan = 14 * 24 * 60 * 60; // two weeks
|
||||
regtest.pow.targetSpacing = 10 * 60;
|
||||
regtest.pow.diffInterval = regtest.pow.targetTimespan / regtest.pow.targetSpacing | 0;
|
||||
regtest.pow.allowMinDifficultyBlocks = true;
|
||||
regtest.pow.noRetargeting = true;
|
||||
|
||||
regtest.block = {
|
||||
majorityEnforceUpgrade: 750,
|
||||
@ -615,15 +621,17 @@ segnet3.genesis = {
|
||||
|
||||
segnet3.magic = 0xcaea962e;
|
||||
|
||||
segnet3.powLimit = new bn(
|
||||
segnet3.pow = {};
|
||||
|
||||
segnet3.pow.limit = new bn(
|
||||
'00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
|
||||
'hex'
|
||||
);
|
||||
segnet3.powTargetTimespan = 14 * 24 * 60 * 60; // two weeks
|
||||
segnet3.powTargetSpacing = 10 * 60;
|
||||
segnet3.powDiffInterval = segnet3.powTargetTimespan / segnet3.powTargetSpacing | 0;
|
||||
segnet3.powAllowMinDifficultyBlocks = true;
|
||||
segnet3.powNoRetargeting = false;
|
||||
segnet3.pow.targetTimespan = 14 * 24 * 60 * 60; // two weeks
|
||||
segnet3.pow.targetSpacing = 10 * 60;
|
||||
segnet3.pow.diffInterval = segnet3.pow.targetTimespan / segnet3.pow.targetSpacing | 0;
|
||||
segnet3.pow.allowMinDifficultyBlocks = true;
|
||||
segnet3.pow.noRetargeting = false;
|
||||
|
||||
segnet3.block = {
|
||||
majorityEnforceUpgrade: 7,
|
||||
@ -657,7 +665,9 @@ segnet4.port = 28901;
|
||||
segnet4.segwitHeight = -1;
|
||||
segnet4.magic = 0xc4a1abdc;
|
||||
|
||||
segnet4.powLimit = new bn(
|
||||
segnet4.pow = utils.merge({}, segnet3.pow);
|
||||
|
||||
segnet4.pow.limit = new bn(
|
||||
// 512x lower min difficulty than mainnet
|
||||
'000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
|
||||
'hex'
|
||||
|
||||
@ -88,7 +88,7 @@ Parser.prototype.feed = function feed(data) {
|
||||
*/
|
||||
|
||||
Parser.prototype.parse = function parse(chunk) {
|
||||
if (chunk.length > constants.maxMessage)
|
||||
if (chunk.length > constants.MAX_MESSAGE)
|
||||
return this._error('Packet too large: %dmb.', utils.mb(chunk.length));
|
||||
|
||||
if (this.packet === null) {
|
||||
@ -138,7 +138,7 @@ Parser.prototype.parseHeader = function parseHeader(h) {
|
||||
cmd = h.toString('ascii', 4, 4 + i);
|
||||
this.waiting = utils.readU32(h, 16);
|
||||
|
||||
if (this.waiting > constants.maxMessage)
|
||||
if (this.waiting > constants.MAX_MESSAGE)
|
||||
return this._error('Packet length too large: %dmb', utils.mb(this.waiting));
|
||||
|
||||
return {
|
||||
@ -276,9 +276,9 @@ Parser.parseFilterLoad = function parseFilterLoad(p) {
|
||||
filter = p.readVarBytes();
|
||||
n = p.readU32();
|
||||
tweak = p.readU32();
|
||||
update = constants.filterFlagsByVal[p.readU8()];
|
||||
update = p.readU8();
|
||||
|
||||
assert(update != null, 'Bad filter flag.');
|
||||
assert(constants.filterFlagsByVal[update] != null, 'Bad filter flag.');
|
||||
|
||||
return {
|
||||
filter: filter,
|
||||
@ -553,7 +553,7 @@ Parser.parsePong = function parsePong(p) {
|
||||
* @property {Number?} port - Port.
|
||||
* @property {Boolean?} network - Whether network services are enabled.
|
||||
* @property {Boolean?} getutxo - Whether peer supports getutxos.
|
||||
* @property {Boolean?} bloom - Whether peer supports serving filteredblocks.
|
||||
* @property {Boolean?} bloom - Whether peer supports serving FILTERED_BLOCKs.
|
||||
* @property {Boolean?} witness - Whether peer supports segwit.
|
||||
* @property {Number} _size
|
||||
*/
|
||||
@ -607,10 +607,10 @@ Parser.parseVersion = function parseVersion(p) {
|
||||
return {
|
||||
version: version,
|
||||
services: services,
|
||||
network: (services & constants.services.network) !== 0,
|
||||
getutxo: (services & constants.services.getutxo) !== 0,
|
||||
bloom: (services & constants.services.bloom) !== 0,
|
||||
witness: (services & constants.services.witness) !== 0,
|
||||
network: (services & constants.services.NETWORK) !== 0,
|
||||
getutxo: (services & constants.services.GETUTXO) !== 0,
|
||||
bloom: (services & constants.services.BLOOM) !== 0,
|
||||
witness: (services & constants.services.WITNESS) !== 0,
|
||||
ts: ts,
|
||||
local: recv,
|
||||
remote: from,
|
||||
@ -676,7 +676,7 @@ Parser._parseGetBlocks = function _parseGetBlocks(p) {
|
||||
|
||||
stop = p.readHash('hex');
|
||||
|
||||
if (stop === constants.nullHash)
|
||||
if (stop === constants.NULL_HASH)
|
||||
stop = null;
|
||||
|
||||
return {
|
||||
@ -1353,10 +1353,10 @@ Parser.parseAddress = function parseAddress(p, full) {
|
||||
return {
|
||||
ts: ts,
|
||||
services: services,
|
||||
network: (services & constants.services.network) !== 0,
|
||||
getutxo: (services & constants.services.getutxo) !== 0,
|
||||
bloom: (services & constants.services.bloom) !== 0,
|
||||
witness: (services & constants.services.witness) !== 0,
|
||||
network: (services & constants.services.NETWORK) !== 0,
|
||||
getutxo: (services & constants.services.GETUTXO) !== 0,
|
||||
bloom: (services & constants.services.BLOOM) !== 0,
|
||||
witness: (services & constants.services.WITNESS) !== 0,
|
||||
ipv6: utils.array2ip(ip, 6),
|
||||
ipv4: utils.array2ip(ip, 4),
|
||||
port: port,
|
||||
|
||||
@ -913,14 +913,14 @@ Script.prototype.interpret = function interpret(stack, flags, tx, index, version
|
||||
stack.state.length = 0;
|
||||
stack.negate = 0;
|
||||
|
||||
if (this.getSize() > constants.script.maxSize)
|
||||
if (this.getSize() > constants.script.MAX_SIZE)
|
||||
throw new ScriptError('Script too large.');
|
||||
|
||||
for (ip = 0; ip < this.code.length; ip++) {
|
||||
op = this.code[ip];
|
||||
|
||||
if (Buffer.isBuffer(op)) {
|
||||
if (op.length > constants.script.maxPush)
|
||||
if (op.length > constants.script.MAX_PUSH)
|
||||
throw new ScriptError('Push data too large.', op, ip);
|
||||
// Note that minimaldata is not checked
|
||||
// on unexecuted branches of code.
|
||||
@ -932,7 +932,7 @@ Script.prototype.interpret = function interpret(stack, flags, tx, index, version
|
||||
continue;
|
||||
}
|
||||
|
||||
if (op > opcodes.OP_16 && ++opCount > constants.script.maxOps)
|
||||
if (op > opcodes.OP_16 && ++opCount > constants.script.MAX_OPS)
|
||||
throw new ScriptError('Too many opcodes.', op, ip);
|
||||
|
||||
// It's very important to make a distiction
|
||||
@ -1390,7 +1390,7 @@ Script.prototype.interpret = function interpret(stack, flags, tx, index, version
|
||||
|
||||
n = Script.num(stack.pop(), flags).toNumber();
|
||||
|
||||
if (!(n >= 1 && n <= constants.script.maxPubkeysPerMultisig))
|
||||
if (!(n >= 1 && n <= constants.script.MAX_MULTISIG_PUBKEYS))
|
||||
throw new ScriptError('`n` is out of bounds.', op, ip);
|
||||
|
||||
if (stack.length < n + 1)
|
||||
@ -1508,7 +1508,7 @@ Script.prototype.interpret = function interpret(stack, flags, tx, index, version
|
||||
|
||||
locktime = locktime.uand(utils.U32).toNumber();
|
||||
|
||||
if ((locktime & constants.sequenceLocktimeDisableFlag) !== 0)
|
||||
if ((locktime & constants.sequence.DISABLE_FLAG) !== 0)
|
||||
break;
|
||||
|
||||
if (!Script.checkSequence(locktime, tx, index))
|
||||
@ -1522,7 +1522,7 @@ Script.prototype.interpret = function interpret(stack, flags, tx, index, version
|
||||
v2 = stack.pop();
|
||||
v1 = stack.pop();
|
||||
stack.push(Buffer.concat([v1, v2]));
|
||||
if (stack.top(-1).length > constants.script.maxPush)
|
||||
if (stack.top(-1).length > constants.script.MAX_PUSH)
|
||||
throw new ScriptError('Push data too large.', op, ip);
|
||||
break;
|
||||
}
|
||||
@ -1603,7 +1603,7 @@ Script.prototype.interpret = function interpret(stack, flags, tx, index, version
|
||||
}
|
||||
}
|
||||
|
||||
if (stack.getSize() > constants.script.maxStack)
|
||||
if (stack.getSize() > constants.script.MAX_STACK)
|
||||
throw new ScriptError('Stack size too large.', op, ip);
|
||||
|
||||
if (stack.state.length !== 0)
|
||||
@ -1621,7 +1621,7 @@ Script.prototype.interpret = function interpret(stack, flags, tx, index, version
|
||||
*/
|
||||
|
||||
Script.checkLocktime = function checkLocktime(locktime, tx, i) {
|
||||
var threshold = constants.locktimeThreshold;
|
||||
var threshold = constants.LOCKTIME_THRESHOLD;
|
||||
|
||||
if (!(
|
||||
(tx.locktime < threshold && locktime < threshold)
|
||||
@ -1654,19 +1654,19 @@ Script.checkSequence = function checkSequence(sequence, tx, i) {
|
||||
if (tx.version < 2)
|
||||
return false;
|
||||
|
||||
if (txSequence & constants.sequenceLocktimeDisableFlag)
|
||||
if (txSequence & constants.sequence.DISABLE_FLAG)
|
||||
return false;
|
||||
|
||||
locktimeMask = constants.sequenceLocktimeTypeFlag
|
||||
| constants.sequenceLocktimeMask;
|
||||
locktimeMask = constants.sequence.TYPE_FLAG
|
||||
| constants.sequence.MASK;
|
||||
txSequenceMasked = txSequence & locktimeMask;
|
||||
sequenceMasked = sequence & locktimeMask;
|
||||
|
||||
if (!(
|
||||
(txSequenceMasked < constants.sequenceLocktimeTypeFlag
|
||||
&& sequenceMasked < constants.sequenceLocktimeTypeFlag)
|
||||
|| (txSequenceMasked >= constants.sequenceLocktimeTypeFlag
|
||||
&& sequenceMasked >= constants.sequenceLocktimeTypeFlag)
|
||||
(txSequenceMasked < constants.sequence.TYPE_FLAG
|
||||
&& sequenceMasked < constants.sequence.TYPE_FLAG)
|
||||
|| (txSequenceMasked >= constants.sequence.TYPE_FLAG
|
||||
&& sequenceMasked >= constants.sequence.TYPE_FLAG)
|
||||
)) {
|
||||
return false;
|
||||
}
|
||||
@ -1971,7 +1971,7 @@ Script.createScripthash = function createScripthash(hash) {
|
||||
|
||||
Script.createNulldata = function createNulldata(flags) {
|
||||
assert(Buffer.isBuffer(flags));
|
||||
assert(flags.length <= constants.script.maxOpReturn, 'Nulldata too large.');
|
||||
assert(flags.length <= constants.script.MAX_OP_RETURN, 'Nulldata too large.');
|
||||
return new Script([
|
||||
opcodes.OP_RETURN,
|
||||
flags
|
||||
@ -2087,7 +2087,7 @@ Script.prototype.isStandard = function isStandard() {
|
||||
if (m < 1 || m > n)
|
||||
return false;
|
||||
} else if (type === 'nulldata') {
|
||||
if (this.getSize() > constants.script.maxOpReturnBytes)
|
||||
if (this.getSize() > constants.script.MAX_OP_RETURN_BYTES)
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -2128,7 +2128,7 @@ Script.prototype.isStandardProgram = function isStandardProgram(witness, flags)
|
||||
}
|
||||
|
||||
for (i = 0; i < witness.items.length; i++) {
|
||||
if (witness.items[i].length > constants.script.maxSize)
|
||||
if (witness.items[i].length > constants.script.MAX_SIZE)
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -2837,7 +2837,7 @@ Script.isZero = function isZero(op) {
|
||||
*/
|
||||
|
||||
Script.isData = function isData(data) {
|
||||
return Buffer.isBuffer(data) && data.length <= constants.script.maxOpReturn;
|
||||
return Buffer.isBuffer(data) && data.length <= constants.script.MAX_OP_RETURN;
|
||||
};
|
||||
|
||||
/**
|
||||
@ -3045,7 +3045,7 @@ Script.isHashType = function isHashType(sig) {
|
||||
if (sig.length === 0)
|
||||
return false;
|
||||
|
||||
type = sig[sig.length - 1] & ~constants.hashType.anyonecanpay;
|
||||
type = sig[sig.length - 1] & ~constants.hashType.ANYONECANPAY;
|
||||
|
||||
if (!constants.hashTypeByVal[type])
|
||||
return false;
|
||||
@ -3168,7 +3168,7 @@ Script.prototype.getSigops = function getSigops(accurate) {
|
||||
if (accurate && lastOp >= opcodes.OP_1 && lastOp <= opcodes.OP_16)
|
||||
total += lastOp - 0x50;
|
||||
else
|
||||
total += constants.script.maxPubkeysPerMultisig;
|
||||
total += constants.script.MAX_MULTISIG_PUBKEYS;
|
||||
}
|
||||
|
||||
lastOp = op;
|
||||
@ -3514,7 +3514,7 @@ Script.verifyProgram = function verifyProgram(witness, output, flags, tx, i) {
|
||||
}
|
||||
|
||||
for (j = 0; j < stack.length; j++) {
|
||||
if (stack.get(j).length > constants.script.maxSize)
|
||||
if (stack.get(j).length > constants.script.MAX_SIZE)
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@ -202,8 +202,8 @@ TX.prototype.hash = function hash(enc) {
|
||||
TX.prototype.witnessHash = function witnessHash(enc) {
|
||||
if (this.isCoinbase()) {
|
||||
return enc === 'hex'
|
||||
? utils.toHex(constants.zeroHash)
|
||||
: utils.slice(constants.zeroHash);
|
||||
? utils.toHex(constants.ZERO_HASH)
|
||||
: utils.slice(constants.ZERO_HASH);
|
||||
}
|
||||
|
||||
if (!this.hasWitness())
|
||||
@ -359,7 +359,7 @@ TX.prototype.signatureHashV0 = function signatureHashV0(index, prev, type) {
|
||||
index = this.inputs.indexOf(index);
|
||||
|
||||
if (typeof type === 'string')
|
||||
type = constants.hashType[type];
|
||||
type = constants.hashType[type.toUpperCase()];
|
||||
|
||||
assert(index >= 0 && index < this.inputs.length);
|
||||
assert(prev instanceof Script);
|
||||
@ -395,7 +395,7 @@ TX.prototype.signatureHashV0 = function signatureHashV0(index, prev, type) {
|
||||
// Set our input to previous output's script
|
||||
copy.inputs[index].script = prev;
|
||||
|
||||
if ((type & 0x1f) === constants.hashType.none) {
|
||||
if ((type & 0x1f) === constants.hashType.NONE) {
|
||||
// Drop all outputs. We don't want to sign them.
|
||||
copy.outputs.length = 0;
|
||||
|
||||
@ -404,11 +404,11 @@ TX.prototype.signatureHashV0 = function signatureHashV0(index, prev, type) {
|
||||
if (i !== index)
|
||||
copy.inputs[i].sequence = 0;
|
||||
}
|
||||
} else if ((type & 0x1f) === constants.hashType.single) {
|
||||
} else if ((type & 0x1f) === constants.hashType.SINGLE) {
|
||||
// Bitcoind used to return 1 as an error code:
|
||||
// it ended up being treated like a hash.
|
||||
if (index >= copy.outputs.length)
|
||||
return utils.slice(constants.oneHash);
|
||||
return utils.slice(constants.ONE_HASH);
|
||||
|
||||
// Drop all the outputs after the input index.
|
||||
copy.outputs.length = index + 1;
|
||||
@ -429,7 +429,7 @@ TX.prototype.signatureHashV0 = function signatureHashV0(index, prev, type) {
|
||||
}
|
||||
|
||||
// Only sign our input. Allows anyone to add inputs.
|
||||
if (type & constants.hashType.anyonecanpay) {
|
||||
if (type & constants.hashType.ANYONECANPAY) {
|
||||
copy.inputs[0] = copy.inputs[index];
|
||||
copy.inputs.length = 1;
|
||||
}
|
||||
@ -449,12 +449,12 @@ TX.prototype.signatureHashV1 = function signatureHashV1(index, prev, type) {
|
||||
index = this.inputs.indexOf(index);
|
||||
|
||||
if (typeof type === 'string')
|
||||
type = constants.hashType[type];
|
||||
type = constants.hashType[type.toUpperCase()];
|
||||
|
||||
assert(index >= 0 && index < this.inputs.length);
|
||||
assert(prev instanceof Script);
|
||||
|
||||
if (!(type & constants.hashType.anyonecanpay)) {
|
||||
if (!(type & constants.hashType.ANYONECANPAY)) {
|
||||
hashPrevouts = new BufferWriter();
|
||||
for (i = 0; i < this.inputs.length; i++) {
|
||||
prevout = this.inputs[i].prevout;
|
||||
@ -463,31 +463,31 @@ TX.prototype.signatureHashV1 = function signatureHashV1(index, prev, type) {
|
||||
}
|
||||
hashPrevouts = utils.dsha256(hashPrevouts.render());
|
||||
} else {
|
||||
hashPrevouts = utils.slice(constants.zeroHash);
|
||||
hashPrevouts = utils.slice(constants.ZERO_HASH);
|
||||
}
|
||||
|
||||
if (!(type & constants.hashType.anyonecanpay)
|
||||
&& (type & 0x1f) !== constants.hashType.single
|
||||
&& (type & 0x1f) !== constants.hashType.none) {
|
||||
if (!(type & constants.hashType.ANYONECANPAY)
|
||||
&& (type & 0x1f) !== constants.hashType.SINGLE
|
||||
&& (type & 0x1f) !== constants.hashType.NONE) {
|
||||
hashSequence = new BufferWriter();
|
||||
for (i = 0; i < this.inputs.length; i++)
|
||||
hashSequence.writeU32(this.inputs[i].sequence);
|
||||
hashSequence = utils.dsha256(hashSequence.render());
|
||||
} else {
|
||||
hashSequence = utils.slice(constants.zeroHash);
|
||||
hashSequence = utils.slice(constants.ZERO_HASH);
|
||||
}
|
||||
|
||||
if ((type & 0x1f) !== constants.hashType.single
|
||||
&& (type & 0x1f) !== constants.hashType.none) {
|
||||
if ((type & 0x1f) !== constants.hashType.SINGLE
|
||||
&& (type & 0x1f) !== constants.hashType.NONE) {
|
||||
hashOutputs = new BufferWriter();
|
||||
for (i = 0; i < this.outputs.length; i++)
|
||||
bcoin.protocol.framer.output(this.outputs[i], hashOutputs);
|
||||
hashOutputs = utils.dsha256(hashOutputs.render());
|
||||
} else if ((type & 0x1f) === constants.hashType.single && index < this.outputs.length) {
|
||||
} else if ((type & 0x1f) === constants.hashType.SINGLE && index < this.outputs.length) {
|
||||
hashOutputs = bcoin.protocol.framer.output(this.outputs[index]);
|
||||
hashOutputs = utils.dsha256(hashOutputs);
|
||||
} else {
|
||||
hashOutputs = utils.slice(constants.zeroHash);
|
||||
hashOutputs = utils.slice(constants.ZERO_HASH);
|
||||
}
|
||||
|
||||
p.write32(this.version);
|
||||
@ -595,7 +595,7 @@ TX.prototype.verifyAsync = function verifyAsync(index, force, flags, callback) {
|
||||
|
||||
TX.prototype.isCoinbase = function isCoinbase() {
|
||||
return this.inputs.length === 1
|
||||
&& this.inputs[0].prevout.hash === constants.nullHash;
|
||||
&& this.inputs[0].prevout.hash === constants.NULL_HASH;
|
||||
};
|
||||
|
||||
/**
|
||||
@ -855,7 +855,7 @@ TX.prototype.fillCoins = function fillCoins(coins) {
|
||||
*/
|
||||
|
||||
TX.prototype.isFinal = function isFinal(height, ts) {
|
||||
var threshold = constants.locktimeThreshold;
|
||||
var threshold = constants.LOCKTIME_THRESHOLD;
|
||||
var i;
|
||||
|
||||
if (this.locktime === 0)
|
||||
@ -980,7 +980,7 @@ TX.prototype.isSane = function isSane(ret) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (this.getVirtualSize() > constants.block.maxSize) {
|
||||
if (this.getVirtualSize() > constants.block.MAX_SIZE) {
|
||||
ret.reason = 'bad-txns-oversize';
|
||||
ret.score = 100;
|
||||
return false;
|
||||
@ -995,7 +995,7 @@ TX.prototype.isSane = function isSane(ret) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (output.value.cmp(constants.maxMoney) > 0) {
|
||||
if (output.value.cmp(constants.MAX_MONEY) > 0) {
|
||||
ret.reason = 'bad-txns-vout-toolarge';
|
||||
ret.score = 100;
|
||||
return false;
|
||||
@ -1003,7 +1003,7 @@ TX.prototype.isSane = function isSane(ret) {
|
||||
|
||||
total.iadd(output.value);
|
||||
|
||||
if (total.cmpn(0) < 0 || total.cmp(constants.maxMoney) > 0) {
|
||||
if (total.cmpn(0) < 0 || total.cmp(constants.MAX_MONEY) > 0) {
|
||||
ret.reason = 'bad-txns-txouttotal-toolarge';
|
||||
ret.score = 100;
|
||||
return false;
|
||||
@ -1031,7 +1031,7 @@ TX.prototype.isSane = function isSane(ret) {
|
||||
} else {
|
||||
for (i = 0; i < this.inputs.length; i++) {
|
||||
input = this.inputs[i];
|
||||
if (input.prevout.hash === constants.nullHash
|
||||
if (input.prevout.hash === constants.NULL_HASH
|
||||
&& input.prevout.index === 0xffffffff) {
|
||||
ret.reason = 'bad-txns-prevout-null';
|
||||
ret.score = 10;
|
||||
@ -1065,12 +1065,12 @@ TX.prototype.isStandard = function isStandard(flags, ret) {
|
||||
if (flags == null)
|
||||
flags = constants.flags.STANDARD_VERIFY_FLAGS;
|
||||
|
||||
if (this.version < 1 || this.version > constants.tx.version) {
|
||||
if (this.version < 1 || this.version > constants.tx.MAX_VERSION) {
|
||||
ret.reason = 'version';
|
||||
return false;
|
||||
}
|
||||
|
||||
if (this.getVirtualSize() > constants.tx.maxSize) {
|
||||
if (this.getVirtualSize() > constants.tx.MAX_SIZE) {
|
||||
ret.reason = 'tx-size';
|
||||
return false;
|
||||
}
|
||||
@ -1104,12 +1104,12 @@ TX.prototype.isStandard = function isStandard(flags, ret) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (output.script.isMultisig() && !constants.tx.bareMultisig) {
|
||||
if (output.script.isMultisig() && !constants.tx.BARE_MULTISIG) {
|
||||
ret.reason = 'bare-multisig';
|
||||
return false;
|
||||
}
|
||||
|
||||
if (output.value.cmpn(constants.tx.dustThreshold) < 0) {
|
||||
if (output.value.cmpn(constants.tx.DUST_THRESHOLD) < 0) {
|
||||
ret.reason = 'dust';
|
||||
return false;
|
||||
}
|
||||
@ -1132,7 +1132,7 @@ TX.prototype.isStandard = function isStandard(flags, ret) {
|
||||
*/
|
||||
|
||||
TX.prototype.hasStandardInputs = function hasStandardInputs(flags) {
|
||||
var maxSigops = constants.script.maxScripthashSigops;
|
||||
var maxSigops = constants.script.MAX_SCRIPTHASH_SIGOPS;
|
||||
var VERIFY_NONE = constants.flags.VERIFY_NONE;
|
||||
var i, input, stack, res, redeem;
|
||||
|
||||
@ -1208,14 +1208,14 @@ TX.prototype.checkInputs = function checkInputs(spendHeight, ret) {
|
||||
coin = input.coin;
|
||||
|
||||
if (coin.coinbase) {
|
||||
if (spendHeight - coin.height < constants.tx.coinbaseMaturity) {
|
||||
if (spendHeight - coin.height < constants.tx.COINBASE_MATURITY) {
|
||||
ret.reason = 'bad-txns-premature-spend-of-coinbase';
|
||||
ret.score = 0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (coin.value.cmpn(0) < 0 || coin.value.cmp(constants.maxMoney) > 0) {
|
||||
if (coin.value.cmpn(0) < 0 || coin.value.cmp(constants.MAX_MONEY) > 0) {
|
||||
ret.reason = 'bad-txns-inputvalues-outofrange';
|
||||
ret.score = 100;
|
||||
return false;
|
||||
@ -1224,7 +1224,7 @@ TX.prototype.checkInputs = function checkInputs(spendHeight, ret) {
|
||||
total.iadd(coin.value);
|
||||
}
|
||||
|
||||
if (total.cmpn(0) < 0 || total.cmp(constants.maxMoney) > 0) {
|
||||
if (total.cmpn(0) < 0 || total.cmp(constants.MAX_MONEY) > 0) {
|
||||
ret.reason = 'bad-txns-inputvalues-outofrange';
|
||||
ret.score = 100;
|
||||
return false;
|
||||
@ -1246,7 +1246,7 @@ TX.prototype.checkInputs = function checkInputs(spendHeight, ret) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (fee.cmp(constants.maxMoney) > 0) {
|
||||
if (fee.cmp(constants.MAX_MONEY) > 0) {
|
||||
ret.reason = 'bad-txns-fee-outofrange';
|
||||
ret.score = 100;
|
||||
return false;
|
||||
@ -1357,7 +1357,7 @@ TX.prototype.isFree = function isFree(height, size) {
|
||||
|
||||
priority = this.getPriority(height, size);
|
||||
|
||||
return priority.cmp(constants.tx.freeThreshold) > 0;
|
||||
return priority.cmp(constants.tx.FREE_THRESHOLD) > 0;
|
||||
};
|
||||
|
||||
/**
|
||||
@ -1374,10 +1374,10 @@ TX.prototype.getMinFee = function getMinFee(size) {
|
||||
if (size == null)
|
||||
size = this.maxSize();
|
||||
|
||||
fee = new bn(constants.tx.minFee).muln(size).divn(1000);
|
||||
fee = new bn(constants.tx.MIN_FEE).muln(size).divn(1000);
|
||||
|
||||
if (fee.cmpn(0) === 0 && constants.tx.minFee > 0)
|
||||
fee = new bn(constants.tx.minFee);
|
||||
if (fee.cmpn(0) === 0 && constants.tx.MIN_FEE > 0)
|
||||
fee = new bn(constants.tx.MIN_FEE);
|
||||
|
||||
return fee;
|
||||
};
|
||||
@ -1397,10 +1397,10 @@ TX.prototype.getMaxFee = function getMaxFee(size) {
|
||||
if (size == null)
|
||||
size = this.maxSize();
|
||||
|
||||
fee = new bn(constants.tx.minFee).muln(Math.ceil(size / 1000));
|
||||
fee = new bn(constants.tx.MIN_FEE).muln(Math.ceil(size / 1000));
|
||||
|
||||
if (fee.cmpn(0) === 0 && constants.tx.minFee > 0)
|
||||
fee = new bn(constants.tx.minFee);
|
||||
if (fee.cmpn(0) === 0 && constants.tx.MIN_FEE > 0)
|
||||
fee = new bn(constants.tx.MIN_FEE);
|
||||
|
||||
return fee;
|
||||
};
|
||||
@ -1486,10 +1486,10 @@ TX.prototype.isWatched = function isWatched(bloom) {
|
||||
output = this.outputs[i];
|
||||
// Test the output script
|
||||
if (testScript(output.script.code)) {
|
||||
if (bloom.update === 'all') {
|
||||
if (bloom.update === constants.filterFlags.ALL) {
|
||||
outpoint = bcoin.protocol.framer.outpoint(this.hash(), i);
|
||||
bloom.add(outpoint);
|
||||
} else if (bloom.update === 'pubkeyOnly') {
|
||||
} else if (bloom.update === constants.filterFlags.PUBKEY_ONLY) {
|
||||
if (output.script.isPubkey() || output.script.isMultisig()) {
|
||||
outpoint = bcoin.protocol.framer.outpoint(this.hash(), i);
|
||||
bloom.add(outpoint);
|
||||
@ -1718,7 +1718,7 @@ TX.prototype.toExtended = function toExtended(saveCoins) {
|
||||
|
||||
bcoin.protocol.framer.renderTX(this, true, p);
|
||||
p.writeU32(height);
|
||||
p.writeHash(this.block || constants.zeroHash);
|
||||
p.writeHash(this.block || constants.ZERO_HASH);
|
||||
p.writeU32(index);
|
||||
p.writeU32(this.ts);
|
||||
p.writeU32(this.ps);
|
||||
@ -1764,7 +1764,7 @@ TX._fromExtended = function _fromExtended(buf, saveCoins) {
|
||||
tx.ps = p.readU32();
|
||||
// tx.changeIndex = p.readU32();
|
||||
|
||||
if (tx.block === constants.nullHash)
|
||||
if (tx.block === constants.NULL_HASH)
|
||||
tx.block = null;
|
||||
|
||||
if (tx.height === 0x7fffffff)
|
||||
|
||||
@ -505,7 +505,7 @@ Wallet.prototype.deriveAddress = function deriveAddress(change, index) {
|
||||
data = {
|
||||
path: this.createPath(this.cosignerIndex, change, index),
|
||||
cosignerIndex: this.copayBIP45
|
||||
? constants.hd.hardened - 1
|
||||
? constants.hd.HARDENED - 1
|
||||
: this.cosignerIndex,
|
||||
change: change,
|
||||
index: index
|
||||
@ -579,7 +579,7 @@ Wallet.prototype.hasAddress = function hasAddress(address) {
|
||||
|
||||
Wallet.prototype.createPath = function createPath(cosignerIndex, change, index) {
|
||||
if (this.copayBIP45)
|
||||
cosignerIndex = constants.hd.hardened - 1;
|
||||
cosignerIndex = constants.hd.HARDENED - 1;
|
||||
|
||||
return 'm'
|
||||
+ (this.derivation === 'bip45' ? '/' + cosignerIndex : '')
|
||||
@ -608,7 +608,7 @@ Wallet.prototype.parsePath = function parsePath(path) {
|
||||
parts = path.split('/');
|
||||
|
||||
if (this.derivation === 'bip45' && this.copayBIP45)
|
||||
assert(+parts[parts.length - 3] === constants.hd.hardened - 1);
|
||||
assert(+parts[parts.length - 3] === constants.hd.HARDENED - 1);
|
||||
|
||||
return {
|
||||
path: path,
|
||||
|
||||
@ -26,13 +26,13 @@ function createGenesisBlock(options) {
|
||||
}
|
||||
|
||||
if (!options.reward)
|
||||
options.reward = new bn(50).mul(constants.coin);
|
||||
options.reward = new bn(50).mul(constants.COIN);
|
||||
|
||||
tx = {
|
||||
version: 1,
|
||||
inputs: [{
|
||||
prevout: {
|
||||
hash: constants.nullHash,
|
||||
hash: constants.NULL_HASH,
|
||||
index: 0xffffffff
|
||||
},
|
||||
script: {
|
||||
@ -58,7 +58,7 @@ function createGenesisBlock(options) {
|
||||
|
||||
block = {
|
||||
version: options.version,
|
||||
prevBlock: constants.nullHash,
|
||||
prevBlock: constants.NULL_HASH,
|
||||
merkleRoot: utils.toHex(utils.dsha256(txRaw)),
|
||||
ts: options.ts,
|
||||
bits: options.bits,
|
||||
|
||||
@ -7,7 +7,7 @@ var utils = bcoin.utils;
|
||||
var assert = utils.assert;
|
||||
var opcodes = constants.opcodes;
|
||||
|
||||
constants.tx.coinbaseMaturity = 0;
|
||||
constants.tx.COINBASE_MATURITY = 0;
|
||||
|
||||
describe('Chain', function() {
|
||||
var chain, wallet, miner;
|
||||
@ -174,7 +174,7 @@ describe('Chain', function() {
|
||||
});
|
||||
|
||||
it('should cleanup', function(cb) {
|
||||
constants.tx.coinbaseMaturity = 100;
|
||||
constants.tx.COINBASE_MATURITY = 100;
|
||||
cb();
|
||||
});
|
||||
});
|
||||
|
||||
@ -22,7 +22,7 @@ describe('Mempool', function() {
|
||||
var prev = new bcoin.script([w.publicKey, opcodes.OP_CHECKSIG]);
|
||||
var dummyInput = {
|
||||
prevout: {
|
||||
hash: constants.oneHash,
|
||||
hash: constants.ONE_HASH,
|
||||
index: 0
|
||||
},
|
||||
coin: {
|
||||
@ -31,7 +31,7 @@ describe('Mempool', function() {
|
||||
value: new bn(70000),
|
||||
script: prev,
|
||||
coinbase: false,
|
||||
hash: constants.oneHash,
|
||||
hash: constants.ONE_HASH,
|
||||
index: 0
|
||||
},
|
||||
script: new bcoin.script([]),
|
||||
|
||||
@ -27,14 +27,14 @@ describe('Protocol', function() {
|
||||
}
|
||||
|
||||
packetTest('version', {}, function(payload) {
|
||||
assert.equal(payload.version, constants.version);
|
||||
assert.equal(payload.version, constants.VERSION);
|
||||
assert.equal(payload.agent, agent);
|
||||
assert.equal(payload.height, 0);
|
||||
assert.equal(payload.relay, false);
|
||||
});
|
||||
|
||||
packetTest('version', { relay: true, height: 10 }, function(payload) {
|
||||
assert.equal(payload.version, constants.version);
|
||||
assert.equal(payload.version, constants.VERSION);
|
||||
assert.equal(payload.agent, agent);
|
||||
assert.equal(payload.height, 10);
|
||||
assert.equal(payload.relay, true);
|
||||
@ -66,7 +66,7 @@ describe('Protocol', function() {
|
||||
});
|
||||
addr._ipv6 = addr.ipv6;
|
||||
addr.ipv6 = new Buffer(addr.ipv6.replace(/:/g, ''), 'hex');
|
||||
addr.services = constants.localServices;
|
||||
addr.services = constants.LOCAL_SERVICES;
|
||||
});
|
||||
|
||||
packetTest('addr', peers, function(payload) {
|
||||
@ -74,13 +74,13 @@ describe('Protocol', function() {
|
||||
assert.equal(payload.length, 2);
|
||||
|
||||
assert.equal(typeof payload[0].ts, 'number');
|
||||
assert.equal(payload[0].services, constants.localServices);
|
||||
assert.equal(payload[0].services, constants.LOCAL_SERVICES);
|
||||
assert.equal(payload[0].ipv6, peers[0]._ipv6);
|
||||
assert.equal(payload[0].ipv4, peers[0]._ipv4);
|
||||
assert.equal(payload[0].port, peers[0].port);
|
||||
|
||||
assert.equal(typeof payload[1].ts, 'number');
|
||||
assert.equal(payload[1].services, constants.localServices);
|
||||
assert.equal(payload[1].services, constants.LOCAL_SERVICES);
|
||||
assert.equal(payload[1].ipv6, peers[1]._ipv6);
|
||||
assert.equal(payload[1].ipv4, peers[1]._ipv4);
|
||||
assert.equal(payload[1].port, peers[1].port);
|
||||
|
||||
@ -6,16 +6,16 @@ var assert = utils.assert;
|
||||
|
||||
var dummyInput = {
|
||||
prevout: {
|
||||
hash: constants.zeroHash,
|
||||
hash: constants.ZERO_HASH,
|
||||
index: 0
|
||||
},
|
||||
coin: {
|
||||
version: 1,
|
||||
height: 0,
|
||||
value: constants.maxMoney.clone(),
|
||||
value: constants.MAX_MONEY.clone(),
|
||||
script: new bcoin.script([]),
|
||||
coinbase: false,
|
||||
hash: constants.zeroHash,
|
||||
hash: constants.ZERO_HASH,
|
||||
index: 0
|
||||
},
|
||||
script: new bcoin.script([]),
|
||||
@ -336,7 +336,7 @@ describe('Wallet', function() {
|
||||
tx.addOutput(to, 5460);
|
||||
|
||||
var cost = tx.getOutputValue();
|
||||
var total = cost.add(new bn(constants.tx.minFee));
|
||||
var total = cost.add(new bn(constants.tx.MIN_FEE));
|
||||
|
||||
w1.getCoins(function(err, coins1) {
|
||||
assert.noError(err);
|
||||
@ -352,7 +352,7 @@ describe('Wallet', function() {
|
||||
tx.addInput(coins2[0]);
|
||||
|
||||
var left = tx.getInputValue().sub(total);
|
||||
if (left.cmpn(constants.tx.dustThreshold) < 0) {
|
||||
if (left.cmpn(constants.tx.DUST_THRESHOLD) < 0) {
|
||||
tx.outputs[tx.outputs.length - 2].value.iadd(left);
|
||||
left = new bn(0);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user