RanchiMall/fcoin
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more utils refactoring.

Browse Source
This commit is contained in:
Christopher Jeffrey 2016-04-30 20:06:26 -07:00
parent 30abc9bc25
commit 8d38178b30
No known key found for this signature in database
GPG Key ID: 8962AB9DE6666BBD
4 changed files with 156 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/bcoin/chaindb.js
View File

@ -1034,7 +1034,7 @@ ChainDB.prototype.getCoinsByAddress = function getCoinsByAddress(addresses, call
if (typeof addresses === 'string') if (typeof addresses === 'string')
addresses = [addresses]; addresses = [addresses];
addresses = utils.uniqs(addresses); addresses = utils.uniq(addresses);
utils.forEachSerial(addresses, function(address, done) { utils.forEachSerial(addresses, function(address, done) {
var iter = self.db.iterator({ var iter = self.db.iterator({
@ -1146,7 +1146,7 @@ ChainDB.prototype.getTXByAddress = function getTXByAddress(addresses, callback)
if (typeof addresses === 'string') if (typeof addresses === 'string')
addresses = [addresses]; addresses = [addresses];
addresses = utils.uniqs(addresses); addresses = utils.uniq(addresses);
utils.forEachSerial(addresses, function(address, done) { utils.forEachSerial(addresses, function(address, done) {
var iter = self.db.iterator({ var iter = self.db.iterator({

12
lib/bcoin/txdb.js
View File

@ -72,7 +72,7 @@ TXDB.prototype.getMap = function getMap(tx, callback) {
input = tx.getInputAddresses(); input = tx.getInputAddresses();
output = tx.getOutputAddresses(); output = tx.getOutputAddresses();
addresses = utils.uniqs(input.concat(output)); addresses = utils.uniq(input.concat(output));
function cb(err, table) { function cb(err, table) {
if (err) if (err)
@ -95,9 +95,9 @@ TXDB.prototype.getMap = function getMap(tx, callback) {
map.output = map.output.concat(map.table[address]); map.output = map.output.concat(map.table[address]);
}); });
map.input = utils.uniqs(map.input); map.input = utils.uniq(map.input);
map.output = utils.uniqs(map.output); map.output = utils.uniq(map.output);
map.all = utils.uniqs(map.input.concat(map.output)); map.all = utils.uniq(map.input.concat(map.output));
return callback(null, map); return callback(null, map);
} }
@ -1087,7 +1087,7 @@ TXDB.prototype.getHistoryHashes = function getHistoryHashes(address, callback) {
if (err) if (err)
return callback(err); return callback(err);
txs = utils.uniqs(txs); txs = utils.uniq(txs);
return callback(null, txs); return callback(null, txs);
}); });
@ -1162,7 +1162,7 @@ TXDB.prototype.getUnconfirmedHashes = function getUnconfirmedHashes(address, cal
if (err) if (err)
return callback(err); return callback(err);
txs = utils.uniqs(txs); txs = utils.uniq(txs);
return callback(null, txs); return callback(null, txs);
}); });

310
lib/bcoin/utils.js
View File

@ -52,21 +52,21 @@ utils.gc = !utils.isBrowser && typeof gc === 'function' ? gc : utils.nop;
/** /**
* A slow buffer slice (will allocate a new buffer). * A slow buffer slice (will allocate a new buffer).
* @param {Buffer} buf * @param {Buffer} data
* @param {Number?} start * @param {Number?} start
* @param {Number?} end * @param {Number?} end
* @returns {Buffer} * @returns {Buffer}
*/ */
utils.slice = function slice(buf, start, end) { utils.slice = function slice(data, start, end) {
var clone; var clone;
if (start != null) if (start != null)
buf = buf.slice(start, end); data = data.slice(start, end);
clone = new Buffer(buf.length); clone = new Buffer(data.length);
buf.copy(clone, 0, 0, buf.length); data.copy(clone, 0, 0, data.length);
return clone; return clone;
}; };
@ -88,27 +88,27 @@ for (var i = 0; i < base58.length; i++)
/** /**
* Encode a base58 string. * Encode a base58 string.
* @see https://github.com/bitcoin/bitcoin/blob/master/src/base58.cpp * @see https://github.com/bitcoin/bitcoin/blob/master/src/base58.cpp
* @param {Buffer} buf * @param {Buffer} data
* @returns {Base58String} * @returns {Base58String}
*/ */
utils.toBase58 = function toBase58(buf) { utils.toBase58 = function toBase58(data) {
var zeroes = 0; var zeroes = 0;
var length = 0; var length = 0;
var str = ''; var str = '';
var i, b58, carry, j, k; var i, b58, carry, j, k;
for (i = 0; i < buf.length; i++) { for (i = 0; i < data.length; i++) {
if (buf[i] !== 0) if (data[i] !== 0)
break; break;
zeroes++; zeroes++;
} }
b58 = new Buffer(((buf.length * 138 / 100) | 0) + 1); b58 = new Buffer(((data.length * 138 / 100) | 0) + 1);
b58.fill(0); b58.fill(0);
for (; i < buf.length; i++) { for (; i < data.length; i++) {
carry = buf[i]; carry = data[i];
j = 0; j = 0;
for (k = b58.length - 1; k >= 0; k--, j++) { for (k = b58.length - 1; k >= 0; k--, j++) {
if (carry === 0 && j >= length) if (carry === 0 && j >= length)
@ -189,12 +189,12 @@ utils.fromBase58 = function fromBase58(str) {
/** /**
* Test whether a string is base58 (note that you * Test whether a string is base58 (note that you
* may get a false positive on a hex string). * may get a false positive on a hex string).
* @param {String?} msg * @param {String?} obj
* @returns {Boolean} * @returns {Boolean}
*/ */
utils.isBase58 = function isBase58(msg) { utils.isBase58 = function isBase58(obj) {
return typeof msg === 'string' && /^[1-9a-zA-Z]+$/.test(msg); return typeof obj === 'string' && /^[1-9a-zA-Z]+$/.test(obj);
}; };
/** /**
@ -461,12 +461,12 @@ utils.pbkdf2key = function pbkdf2key(passphrase, salt, iterations, dkLen, ivLen,
/** /**
* Test whether a string is hex. Note that this * Test whether a string is hex. Note that this
* may yield a false positive on base58 strings. * may yield a false positive on base58 strings.
* @param {String?} msg * @param {String?} obj
* @returns {Boolean} * @returns {Boolean}
*/ */
utils.isHex = function isHex(msg) { utils.isHex = function isHex(obj) {
return typeof msg === 'string' && /^[0-9a-f]+$/i.test(msg); return typeof obj === 'string' && /^[0-9a-f]+$/i.test(obj);
}; };
/** /**
@ -590,8 +590,8 @@ utils.merge = function merge(target) {
/** /**
* Assertion. * Assertion.
* @param {Boolean} val - Expression. * @param {Boolean} value - Expression.
* @param {String?} msg - Optional error message. * @param {String?} message - Optional error message.
*/ */
utils.assert = function assert(value, message) { utils.assert = function assert(value, message) {
@ -1056,31 +1056,13 @@ utils.sortTX = function sortTX(txs) {
}); });
}; };
/**
* Unique-ify an array.
* @param {Array} obj
* @returns {Array}
*/
utils.uniq = function uniq(obj) {
var out = [];
var i = 0;
for (; i < obj.length; i++) {
if (out.indexOf(obj[i]) === -1)
out.push(obj[i]);
}
return out;
};
/** /**
* Unique-ify an array of strings. * Unique-ify an array of strings.
* @param {String[]} obj * @param {String[]} obj
* @returns {String[]} * @returns {String[]}
*/ */
utils.uniqs = function uniqs(obj) { utils.uniq = function uniq(obj) {
var table = {}; var table = {};
var out = []; var out = [];
var i = 0; var i = 0;
@ -1187,7 +1169,7 @@ utils.now = function now() {
/** /**
* Create a Date ISO string from time in unix time (seconds). * Create a Date ISO string from time in unix time (seconds).
* @param {Number?} - Seconds in unix time. * @param {Number?} ts - Seconds in unix time.
* @returns {String} * @returns {String}
*/ */
@ -1265,187 +1247,187 @@ utils.nonce = function nonce() {
/** /**
* Read uint8. * Read uint8.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.readU8 = function readU8(arr, off) { utils.readU8 = function readU8(data, off) {
off = off >>> 0; off = off >>> 0;
return arr[off]; return data[off];
}; };
/** /**
* Read uint16le. * Read uint16le.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.readU16 = function readU16(arr, off) { utils.readU16 = function readU16(data, off) {
off = off >>> 0; off = off >>> 0;
return arr[off] | (arr[off + 1] << 8); return data[off] | (data[off + 1] << 8);
}; };
/** /**
* Read uint16be. * Read uint16be.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.readU16BE = function readU16BE(arr, off) { utils.readU16BE = function readU16BE(data, off) {
off = off >>> 0; off = off >>> 0;
return (arr[off] << 8) | arr[off + 1]; return (data[off] << 8) | data[off + 1];
}; };
/** /**
* Read uint32le. * Read uint32le.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.readU32 = function readU32(arr, off) { utils.readU32 = function readU32(data, off) {
off = off >>> 0; off = off >>> 0;
return ((arr[off]) return ((data[off])
| (arr[off + 1] << 8) | (data[off + 1] << 8)
| (arr[off + 2] << 16)) | (data[off + 2] << 16))
+ (arr[off + 3] * 0x1000000); + (data[off + 3] * 0x1000000);
}; };
/** /**
* Read uint32be. * Read uint32be.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.readU32BE = function readU32BE(arr, off) { utils.readU32BE = function readU32BE(data, off) {
off = off >>> 0; off = off >>> 0;
return (arr[off] * 0x1000000) return (data[off] * 0x1000000)
+ ((arr[off + 1] << 16) + ((data[off + 1] << 16)
| (arr[off + 2] << 8) | (data[off + 2] << 8)
| arr[off + 3]); | data[off + 3]);
}; };
/** /**
* Read uint64le. * Read uint64le.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {BN} * @returns {BN}
*/ */
utils.readU64 = function readU64(arr, off) { utils.readU64 = function readU64(data, off) {
var num; var num;
off = off >>> 0; off = off >>> 0;
num = arr.slice(off, off + 8); num = data.slice(off, off + 8);
return new bn(num, 'le'); return new bn(num, 'le');
}; };
/** /**
* Read uint64be. * Read uint64be.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {BN} * @returns {BN}
*/ */
utils.readU64BE = function readU64BE(arr, off) { utils.readU64BE = function readU64BE(data, off) {
var num; var num;
off = off >>> 0; off = off >>> 0;
num = arr.slice(off, off + 8); num = data.slice(off, off + 8);
return new bn(num, 'be'); return new bn(num, 'be');
}; };
/** /**
* Read int8. * Read int8.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.read8 = function read8(arr, off) { utils.read8 = function read8(data, off) {
var num; var num;
off = off >>> 0; off = off >>> 0;
num = arr[off]; num = data[off];
return !(num & 0x80) ? num : (0xff - num + 1) * -1; return !(num & 0x80) ? num : (0xff - num + 1) * -1;
}; };
/** /**
* Read int16le. * Read int16le.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.read16 = function read16(arr, off) { utils.read16 = function read16(data, off) {
var num; var num;
off = off >>> 0; off = off >>> 0;
num = arr[off] | (arr[off + 1] << 8); num = data[off] | (data[off + 1] << 8);
return (num & 0x8000) ? num | 0xffff0000 : num; return (num & 0x8000) ? num | 0xffff0000 : num;
}; };
/** /**
* Read int16be. * Read int16be.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.read16BE = function read16BE(arr, off) { utils.read16BE = function read16BE(data, off) {
var num; var num;
off = off >>> 0; off = off >>> 0;
num = arr[off + 1] | (arr[off] << 8); num = data[off + 1] | (data[off] << 8);
return (num & 0x8000) ? num | 0xffff0000 : num; return (num & 0x8000) ? num | 0xffff0000 : num;
}; };
/** /**
* Read int32le. * Read int32le.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.read32 = function read32(arr, off) { utils.read32 = function read32(data, off) {
off = off >>> 0; off = off >>> 0;
return (arr[off]) return (data[off])
| (arr[off + 1] << 8) | (data[off + 1] << 8)
| (arr[off + 2] << 16) | (data[off + 2] << 16)
| (arr[off + 3] << 24); | (data[off + 3] << 24);
}; };
/** /**
* Read int32be. * Read int32be.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.read32BE = function read32BE(arr, off) { utils.read32BE = function read32BE(data, off) {
off = off >>> 0; off = off >>> 0;
return (arr[off] << 24) return (data[off] << 24)
| (arr[off + 1] << 16) | (data[off + 1] << 16)
| (arr[off + 2] << 8) | (data[off + 2] << 8)
| (arr[off + 3]); | (data[off + 3]);
}; };
/** /**
* Read int64le. * Read int64le.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {BN} * @returns {BN}
*/ */
utils.read64 = function read64(arr, off) { utils.read64 = function read64(data, off) {
var num; var num;
off = off >>> 0; off = off >>> 0;
num = arr.slice(off, off + 8); num = data.slice(off, off + 8);
if (num[num.length - 1] & 0x80) if (num[num.length - 1] & 0x80)
return new bn(num, 'le').notn(64).addn(1).neg(); return new bn(num, 'le').notn(64).addn(1).neg();
@ -1455,17 +1437,17 @@ utils.read64 = function read64(arr, off) {
/** /**
* Read int64be. * Read int64be.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {BN} * @returns {BN}
*/ */
utils.read64BE = function read64BE(arr, off) { utils.read64BE = function read64BE(data, off) {
var num; var num;
off = off >>> 0; off = off >>> 0;
num = arr.slice(off, off + 8); num = data.slice(off, off + 8);
if (num[0] & 0x80) if (num[0] & 0x80)
return new bn(num, 'be').notn(64).addn(1).neg(); return new bn(num, 'be').notn(64).addn(1).neg();
@ -1691,17 +1673,17 @@ utils.write64NBE = function write64NBE(dst, num, off) {
/** /**
* Read uint64le as a js number. * Read uint64le as a js number.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @param {Boolean} force53 - Read only 53 bits, but maintain the sign. * @param {Boolean} force53 - Read only 53 bits, but maintain the sign.
* @returns {Number} * @returns {Number}
* @throws on num > MAX_SAFE_INTEGER * @throws on num > MAX_SAFE_INTEGER
*/ */
utils.readU64N = function readU64N(dst, off, force53) { utils.readU64N = function readU64N(data, off, force53) {
off = off >>> 0; off = off >>> 0;
var hi = utils.readU32(dst, off + 4); var hi = utils.readU32(data, off + 4);
var lo = utils.readU32(dst, off); var lo = utils.readU32(data, off);
if (force53) if (force53)
hi &= utils.MAX_SAFE_HI; hi &= utils.MAX_SAFE_HI;
assert(hi <= utils.MAX_SAFE_HI, 'Number exceeds 2^53-1'); assert(hi <= utils.MAX_SAFE_HI, 'Number exceeds 2^53-1');
@ -1710,17 +1692,17 @@ utils.readU64N = function readU64N(dst, off, force53) {
/** /**
* Read uint64be as a js number. * Read uint64be as a js number.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @param {Boolean} force53 - Read only 53 bits, but maintain the sign. * @param {Boolean} force53 - Read only 53 bits, but maintain the sign.
* @returns {Number} * @returns {Number}
* @throws on num > MAX_SAFE_INTEGER * @throws on num > MAX_SAFE_INTEGER
*/ */
utils.readU64NBE = function readU64NBE(dst, off, force53) { utils.readU64NBE = function readU64NBE(data, off, force53) {
off = off >>> 0; off = off >>> 0;
var hi = utils.readU32BE(dst, off); var hi = utils.readU32BE(data, off);
var lo = utils.readU32BE(dst, off + 4); var lo = utils.readU32BE(data, off + 4);
if (force53) if (force53)
hi &= utils.MAX_SAFE_HI; hi &= utils.MAX_SAFE_HI;
assert(hi <= utils.MAX_SAFE_HI, 'Number exceeds 2^53-1'); assert(hi <= utils.MAX_SAFE_HI, 'Number exceeds 2^53-1');
@ -1729,17 +1711,17 @@ utils.readU64NBE = function readU64NBE(dst, off, force53) {
/** /**
* Read int64le as a js number. * Read int64le as a js number.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @param {Boolean} force53 - Read only 53 bits, but maintain the sign. * @param {Boolean} force53 - Read only 53 bits, but maintain the sign.
* @returns {Number} * @returns {Number}
* @throws on num > MAX_SAFE_INTEGER * @throws on num > MAX_SAFE_INTEGER
*/ */
utils.read64N = function read64N(dst, off, force53) { utils.read64N = function read64N(data, off, force53) {
off = off >>> 0; off = off >>> 0;
var hi = utils.readU32(dst, off + 4); var hi = utils.readU32(data, off + 4);
var lo = utils.readU32(dst, off); var lo = utils.readU32(data, off);
if (hi & 0x80000000) { if (hi & 0x80000000) {
hi = ~hi + 1; hi = ~hi + 1;
lo = ~lo + 1; lo = ~lo + 1;
@ -1756,17 +1738,17 @@ utils.read64N = function read64N(dst, off, force53) {
/** /**
* Read int64be as a js number. * Read int64be as a js number.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @param {Boolean} force53 - Read only 53 bits, but maintain the sign. * @param {Boolean} force53 - Read only 53 bits, but maintain the sign.
* @returns {Number} * @returns {Number}
* @throws on num > MAX_SAFE_INTEGER * @throws on num > MAX_SAFE_INTEGER
*/ */
utils.read64NBE = function read64NBE(dst, off, force53) { utils.read64NBE = function read64NBE(data, off, force53) {
off = off >>> 0; off = off >>> 0;
var hi = utils.readU32BE(dst, off); var hi = utils.readU32BE(data, off);
var lo = utils.readU32BE(dst, off + 4); var lo = utils.readU32BE(data, off + 4);
if (hi & 0x80000000) { if (hi & 0x80000000) {
hi = ~hi + 1; hi = ~hi + 1;
lo = ~lo + 1; lo = ~lo + 1;
@ -1784,49 +1766,49 @@ utils.read64NBE = function read64NBE(dst, off, force53) {
/** /**
* Read first least significant 53 bits of * Read first least significant 53 bits of
* a uint64le as a js number. Maintain the sign. * a uint64le as a js number. Maintain the sign.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.readU53 = function readU53(dst, off) { utils.readU53 = function readU53(data, off) {
return utils.readU64N(dst, off, true); return utils.readU64N(data, off, true);
}; };
/** /**
* Read first least significant 53 bits of * Read first least significant 53 bits of
* a uint64be as a js number. Maintain the sign. * a uint64be as a js number. Maintain the sign.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.readU53BE = function readU53BE(dst, off) { utils.readU53BE = function readU53BE(data, off) {
return utils.readU64NBE(dst, off, true); return utils.readU64NBE(data, off, true);
}; };
/** /**
* Read first least significant 53 bits of * Read first least significant 53 bits of
* a uint64le as a js number. Maintain the sign. * a uint64le as a js number. Maintain the sign.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.read53 = function read53(dst, off) { utils.read53 = function read53(data, off) {
return utils.read64N(dst, off, true); return utils.read64N(data, off, true);
}; };
/** /**
* Read first least significant 53 bits of * Read first least significant 53 bits of
* a int64be as a js number. Maintain the sign. * a int64be as a js number. Maintain the sign.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @returns {Number} * @returns {Number}
*/ */
utils.read53BE = function read53BE(dst, off) { utils.read53BE = function read53BE(data, off) {
return utils.read64NBE(dst, off, true); return utils.read64NBE(data, off, true);
}; };
/** /**
@ -1974,42 +1956,42 @@ utils.write64BE = function write64BE(dst, num, off) {
/** /**
* Read a varint. * Read a varint.
* @param {Buffer} arr * @param {Buffer} data
* @param {Number} off * @param {Number} off
* @param {Boolean?} big - Whether to read as a big number. * @param {Boolean?} big - Whether to read as a big number.
* @returns {Number} * @returns {Number}
*/ */
utils.readVarint = function readVarint(arr, off, big) { utils.readVarint = function readVarint(data, off, big) {
var r, bytes; var r, bytes;
off = off >>> 0; off = off >>> 0;
assert(off < arr.length); assert(off < data.length);
if (arr[off] < 0xfd) { if (data[off] < 0xfd) {
r = arr[off]; r = data[off];
if (big) if (big)
r = new bn(r); r = new bn(r);
bytes = 1; bytes = 1;
} else if (arr[off] === 0xfd) { } else if (data[off] === 0xfd) {
assert(off + 2 < arr.length); assert(off + 2 < data.length);
r = arr[off + 1] | (arr[off + 2] << 8); r = data[off + 1] | (data[off + 2] << 8);
if (big) if (big)
r = new bn(r); r = new bn(r);
bytes = 3; bytes = 3;
} else if (arr[off] === 0xfe) { } else if (data[off] === 0xfe) {
assert(off + 4 < arr.length); assert(off + 4 < data.length);
r = utils.readU32(arr, off + 1); r = utils.readU32(data, off + 1);
if (big) if (big)
r = new bn(r); r = new bn(r);
bytes = 5; bytes = 5;
} else if (arr[off] === 0xff) { } else if (data[off] === 0xff) {
assert(off + 8 < arr.length); assert(off + 8 < data.length);
if (big) if (big)
r = utils.readU64(arr, off + 1); r = utils.readU64(data, off + 1);
else else
r = utils.readU64N(arr, off + 1); r = utils.readU64N(data, off + 1);
bytes = 9; bytes = 9;
} else { } else {
assert(false, 'Malformed varint.'); assert(false, 'Malformed varint.');
@ -2227,13 +2209,13 @@ utils.forRange = function forRange(from, to, iter, callback) {
/** /**
* Asynchronously iterate over an array in parallel. * Asynchronously iterate over an array in parallel.
* @param {Array} arr * @param {Array} obj
* @param {Function} iter * @param {Function} iter
* @param {Function} callback * @param {Function} callback
*/ */
utils.forEach = function forEach(arr, iter, callback) { utils.forEach = function forEach(obj, iter, callback) {
var pending = arr.length; var pending = obj.length;
var error; var error;
callback = utils.asyncify(callback); callback = utils.asyncify(callback);
@ -2249,7 +2231,7 @@ utils.forEach = function forEach(arr, iter, callback) {
callback(error); callback(error);
} }
arr.forEach(function(item, i) { obj.forEach(function(item, i) {
iter(item, next, i); iter(item, next, i);
}); });
}; };
@ -2286,12 +2268,12 @@ utils.forRangeSerial = function forRangeSerial(from, to, iter, callback) {
/** /**
* Asynchronously iterate over an array in serial. * Asynchronously iterate over an array in serial.
* @param {Array} arr * @param {Array} obj
* @param {Function} iter * @param {Function} iter
* @param {Function} callback * @param {Function} callback
*/ */
utils.forEachSerial = function forEachSerial(arr, iter, callback) { utils.forEachSerial = function forEachSerial(obj, iter, callback) {
var i = 0; var i = 0;
var called = false; var called = false;
@ -2304,11 +2286,11 @@ utils.forEachSerial = function forEachSerial(arr, iter, callback) {
called = true; called = true;
return callback(err); return callback(err);
} }
if (i >= arr.length) { if (i >= obj.length) {
called = true; called = true;
return callback(); return callback();
} }
item = arr[i]; item = obj[i];
i++; i++;
utils.nextTick(function() { utils.nextTick(function() {
iter(item, next, i - 1); iter(item, next, i - 1);
@ -2319,13 +2301,13 @@ utils.forEachSerial = function forEachSerial(arr, iter, callback) {
/** /**
* Asynchronously apply a truth test to every * Asynchronously apply a truth test to every
* member of an array in parallel. * member of an array in parallel.
* @param {Array} arr * @param {Array} obj
* @param {Function} iter * @param {Function} iter
* @param {Function} callback * @param {Function} callback
*/ */
utils.every = function every(arr, iter, callback) { utils.every = function every(obj, iter, callback) {
var pending = arr.length; var pending = obj.length;
var result = true; var result = true;
var error; var error;
@ -2347,7 +2329,7 @@ utils.every = function every(arr, iter, callback) {
} }
} }
arr.forEach(function(item, i) { obj.forEach(function(item, i) {
iter(item, next, i); iter(item, next, i);
}); });
}; };
@ -2355,12 +2337,12 @@ utils.every = function every(arr, iter, callback) {
/** /**
* Asynchronously apply a truth test to every * Asynchronously apply a truth test to every
* member of an array in serial. * member of an array in serial.
* @param {Array} arr * @param {Array} obj
* @param {Function} iter * @param {Function} iter
* @param {Function} callback * @param {Function} callback
*/ */
utils.everySerial = function everySerial(arr, iter, callback) { utils.everySerial = function everySerial(obj, iter, callback) {
var i = 0; var i = 0;
var called = false; var called = false;
@ -2377,11 +2359,11 @@ utils.everySerial = function everySerial(arr, iter, callback) {
called = true; called = true;
return callback(null, false); return callback(null, false);
} }
if (i >= arr.length) { if (i >= obj.length) {
called = true; called = true;
return callback(null, true); return callback(null, true);
} }
item = arr[i]; item = obj[i];
i++; i++;
utils.nextTick(function() { utils.nextTick(function() {
iter(item, next, i - 1); iter(item, next, i - 1);
@ -2566,21 +2548,21 @@ utils.checkMerkleBranch = function checkMerkleBranch(hash, branch, index) {
/** /**
* Find index of a buffer in an array of buffers. * Find index of a buffer in an array of buffers.
* @param {Buffer[]} arr * @param {Buffer[]} obj
* @param {Buffer} buf - Target buffer to find. * @param {Buffer} data - Target buffer to find.
* @returns {Number} Index (-1 if not found). * @returns {Number} Index (-1 if not found).
*/ */
utils.indexOf = function indexOf(arr, buf) { utils.indexOf = function indexOf(obj, data) {
var i; var i;
assert(Array.isArray(arr)); assert(Array.isArray(obj));
assert(Buffer.isBuffer(buf)); assert(Buffer.isBuffer(data));
for (i = 0; i < arr.length; i++) { for (i = 0; i < obj.length; i++) {
if (!Buffer.isBuffer(arr[i])) if (!Buffer.isBuffer(obj[i]))
continue; continue;
if (utils.equal(arr[i], buf)) if (utils.equal(obj[i], data))
return i; return i;
} }
@ -2695,13 +2677,13 @@ utils.serial = function serial(stack, callback) {
/** /**
* Convert an array to a map. * Convert an array to a map.
* @param {String[]} arr * @param {String[]} obj
* @returns {Object} Map. * @returns {Object} Map.
*/ */
utils.toMap = function toMap(arr) { utils.toMap = function toMap(obj) {
var map = {}; var map = {};
arr.forEach(function(value) { obj.forEach(function(value) {
map[value] = true; map[value] = true;
}); });
return map; return map;

4
lib/bcoin/wallet.js
View File

@ -901,7 +901,7 @@ Wallet.prototype.getInputPaths = function getInputPaths(tx, index) {
paths.push(path); paths.push(path);
} }
return utils.uniqs(paths); return utils.uniq(paths);
}; };
/** /**
@ -937,7 +937,7 @@ Wallet.prototype.getOutputPaths = function getOutputPaths(tx, index) {
paths.push(path); paths.push(path);
} }
return utils.uniqs(paths); return utils.uniq(paths);
}; };
/** /**