diff --git a/lib/bcoin/chaindb.js b/lib/bcoin/chaindb.js
index 0b8a402b..fe7617f1 100644
--- a/lib/bcoin/chaindb.js
+++ b/lib/bcoin/chaindb.js
@@ -1034,7 +1034,7 @@ ChainDB.prototype.getCoinsByAddress = function getCoinsByAddress(addresses, call
   if (typeof addresses === 'string')
     addresses = [addresses];
 
-  addresses = utils.uniqs(addresses);
+  addresses = utils.uniq(addresses);
 
   utils.forEachSerial(addresses, function(address, done) {
     var iter = self.db.iterator({
@@ -1146,7 +1146,7 @@ ChainDB.prototype.getTXByAddress = function getTXByAddress(addresses, callback)
   if (typeof addresses === 'string')
     addresses = [addresses];
 
-  addresses = utils.uniqs(addresses);
+  addresses = utils.uniq(addresses);
 
   utils.forEachSerial(addresses, function(address, done) {
     var iter = self.db.iterator({
diff --git a/lib/bcoin/txdb.js b/lib/bcoin/txdb.js
index 631e086a..a3507711 100644
--- a/lib/bcoin/txdb.js
+++ b/lib/bcoin/txdb.js
@@ -72,7 +72,7 @@ TXDB.prototype.getMap = function getMap(tx, callback) {
 
   input = tx.getInputAddresses();
   output = tx.getOutputAddresses();
-  addresses = utils.uniqs(input.concat(output));
+  addresses = utils.uniq(input.concat(output));
 
   function cb(err, table) {
     if (err)
@@ -95,9 +95,9 @@ TXDB.prototype.getMap = function getMap(tx, callback) {
       map.output = map.output.concat(map.table[address]);
     });
 
-    map.input = utils.uniqs(map.input);
-    map.output = utils.uniqs(map.output);
-    map.all = utils.uniqs(map.input.concat(map.output));
+    map.input = utils.uniq(map.input);
+    map.output = utils.uniq(map.output);
+    map.all = utils.uniq(map.input.concat(map.output));
 
     return callback(null, map);
   }
@@ -1087,7 +1087,7 @@ TXDB.prototype.getHistoryHashes = function getHistoryHashes(address, callback) {
       if (err)
         return callback(err);
 
-      txs = utils.uniqs(txs);
+      txs = utils.uniq(txs);
 
       return callback(null, txs);
     });
@@ -1162,7 +1162,7 @@ TXDB.prototype.getUnconfirmedHashes = function getUnconfirmedHashes(address, cal
       if (err)
         return callback(err);
 
-      txs = utils.uniqs(txs);
+      txs = utils.uniq(txs);
 
       return callback(null, txs);
     });
diff --git a/lib/bcoin/utils.js b/lib/bcoin/utils.js
index d4043e15..342b9115 100644
--- a/lib/bcoin/utils.js
+++ b/lib/bcoin/utils.js
@@ -52,21 +52,21 @@ utils.gc = !utils.isBrowser && typeof gc === 'function' ? gc : utils.nop;
 
 /**
  * A slow buffer slice (will allocate a new buffer).
- * @param {Buffer} buf
+ * @param {Buffer} data
  * @param {Number?} start
  * @param {Number?} end
  * @returns {Buffer}
  */
 
-utils.slice = function slice(buf, start, end) {
+utils.slice = function slice(data, start, end) {
   var clone;
 
   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;
 };
@@ -88,27 +88,27 @@ for (var i = 0; i < base58.length; i++)
 /**
  * Encode a base58 string.
  * @see https://github.com/bitcoin/bitcoin/blob/master/src/base58.cpp
- * @param {Buffer} buf
+ * @param {Buffer} data
  * @returns {Base58String}
  */
 
-utils.toBase58 = function toBase58(buf) {
+utils.toBase58 = function toBase58(data) {
   var zeroes = 0;
   var length = 0;
   var str = '';
   var i, b58, carry, j, k;
 
-  for (i = 0; i < buf.length; i++) {
-    if (buf[i] !== 0)
+  for (i = 0; i < data.length; i++) {
+    if (data[i] !== 0)
       break;
     zeroes++;
   }
 
-  b58 = new Buffer(((buf.length * 138 / 100) | 0) + 1);
+  b58 = new Buffer(((data.length * 138 / 100) | 0) + 1);
   b58.fill(0);
 
-  for (; i < buf.length; i++) {
-    carry = buf[i];
+  for (; i < data.length; i++) {
+    carry = data[i];
     j = 0;
     for (k = b58.length - 1; k >= 0; k--, j++) {
       if (carry === 0 && j >= length)
@@ -189,12 +189,12 @@ utils.fromBase58 = function fromBase58(str) {
 /**
  * Test whether a string is base58 (note that you
  * may get a false positive on a hex string).
- * @param {String?} msg
+ * @param {String?} obj
  * @returns {Boolean}
  */
 
-utils.isBase58 = function isBase58(msg) {
-  return typeof msg === 'string' && /^[1-9a-zA-Z]+$/.test(msg);
+utils.isBase58 = function isBase58(obj) {
+  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
  * may yield a false positive on base58 strings.
- * @param {String?} msg
+ * @param {String?} obj
  * @returns {Boolean}
  */
 
-utils.isHex = function isHex(msg) {
-  return typeof msg === 'string' && /^[0-9a-f]+$/i.test(msg);
+utils.isHex = function isHex(obj) {
+  return typeof obj === 'string' && /^[0-9a-f]+$/i.test(obj);
 };
 
 /**
@@ -590,8 +590,8 @@ utils.merge = function merge(target) {
 
 /**
  * Assertion.
- * @param {Boolean} val - Expression.
- * @param {String?} msg - Optional error message.
+ * @param {Boolean} value - Expression.
+ * @param {String?} message - Optional error 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.
  * @param {String[]} obj
  * @returns {String[]}
  */
 
-utils.uniqs = function uniqs(obj) {
+utils.uniq = function uniq(obj) {
   var table = {};
   var out = [];
   var i = 0;
@@ -1187,7 +1169,7 @@ utils.now = function now() {
 
 /**
  * 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}
  */
 
@@ -1265,187 +1247,187 @@ utils.nonce = function nonce() {
 
 /**
  * Read uint8.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.readU8 = function readU8(arr, off) {
+utils.readU8 = function readU8(data, off) {
   off = off >>> 0;
-  return arr[off];
+  return data[off];
 };
 
 /**
  * Read uint16le.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.readU16 = function readU16(arr, off) {
+utils.readU16 = function readU16(data, off) {
   off = off >>> 0;
-  return arr[off] | (arr[off + 1] << 8);
+  return data[off] | (data[off + 1] << 8);
 };
 
 /**
  * Read uint16be.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.readU16BE = function readU16BE(arr, off) {
+utils.readU16BE = function readU16BE(data, off) {
   off = off >>> 0;
-  return (arr[off] << 8) | arr[off + 1];
+  return (data[off] << 8) | data[off + 1];
 };
 
 /**
  * Read uint32le.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.readU32 = function readU32(arr, off) {
+utils.readU32 = function readU32(data, off) {
   off = off >>> 0;
 
-  return ((arr[off])
-    | (arr[off + 1] << 8)
-    | (arr[off + 2] << 16))
-    + (arr[off + 3] * 0x1000000);
+  return ((data[off])
+    | (data[off + 1] << 8)
+    | (data[off + 2] << 16))
+    + (data[off + 3] * 0x1000000);
 };
 
 /**
  * Read uint32be.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.readU32BE = function readU32BE(arr, off) {
+utils.readU32BE = function readU32BE(data, off) {
   off = off >>> 0;
 
-  return (arr[off] * 0x1000000)
-    + ((arr[off + 1] << 16)
-    | (arr[off + 2] << 8)
-    | arr[off + 3]);
+  return (data[off] * 0x1000000)
+    + ((data[off + 1] << 16)
+    | (data[off + 2] << 8)
+    | data[off + 3]);
 };
 
 /**
  * Read uint64le.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {BN}
  */
 
-utils.readU64 = function readU64(arr, off) {
+utils.readU64 = function readU64(data, off) {
   var num;
   off = off >>> 0;
-  num = arr.slice(off, off + 8);
+  num = data.slice(off, off + 8);
   return new bn(num, 'le');
 };
 
 /**
  * Read uint64be.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {BN}
  */
 
-utils.readU64BE = function readU64BE(arr, off) {
+utils.readU64BE = function readU64BE(data, off) {
   var num;
   off = off >>> 0;
-  num = arr.slice(off, off + 8);
+  num = data.slice(off, off + 8);
   return new bn(num, 'be');
 };
 
 /**
  * Read int8.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.read8 = function read8(arr, off) {
+utils.read8 = function read8(data, off) {
   var num;
   off = off >>> 0;
-  num = arr[off];
+  num = data[off];
   return !(num & 0x80) ? num : (0xff - num + 1) * -1;
 };
 
 /**
  * Read int16le.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.read16 = function read16(arr, off) {
+utils.read16 = function read16(data, off) {
   var num;
   off = off >>> 0;
-  num = arr[off] | (arr[off + 1] << 8);
+  num = data[off] | (data[off + 1] << 8);
   return (num & 0x8000) ? num | 0xffff0000 : num;
 };
 
 /**
  * Read int16be.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.read16BE = function read16BE(arr, off) {
+utils.read16BE = function read16BE(data, off) {
   var num;
   off = off >>> 0;
-  num = arr[off + 1] | (arr[off] << 8);
+  num = data[off + 1] | (data[off] << 8);
   return (num & 0x8000) ? num | 0xffff0000 : num;
 };
 
 /**
  * Read int32le.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.read32 = function read32(arr, off) {
+utils.read32 = function read32(data, off) {
   off = off >>> 0;
 
-  return (arr[off])
-    | (arr[off + 1] << 8)
-    | (arr[off + 2] << 16)
-    | (arr[off + 3] << 24);
+  return (data[off])
+    | (data[off + 1] << 8)
+    | (data[off + 2] << 16)
+    | (data[off + 3] << 24);
 };
 
 /**
  * Read int32be.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.read32BE = function read32BE(arr, off) {
+utils.read32BE = function read32BE(data, off) {
   off = off >>> 0;
 
-  return (arr[off] << 24)
-    | (arr[off + 1] << 16)
-    | (arr[off + 2] << 8)
-    | (arr[off + 3]);
+  return (data[off] << 24)
+    | (data[off + 1] << 16)
+    | (data[off + 2] << 8)
+    | (data[off + 3]);
 };
 
 /**
  * Read int64le.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {BN}
  */
 
-utils.read64 = function read64(arr, off) {
+utils.read64 = function read64(data, off) {
   var num;
 
   off = off >>> 0;
 
-  num = arr.slice(off, off + 8);
+  num = data.slice(off, off + 8);
 
   if (num[num.length - 1] & 0x80)
     return new bn(num, 'le').notn(64).addn(1).neg();
@@ -1455,17 +1437,17 @@ utils.read64 = function read64(arr, off) {
 
 /**
  * Read int64be.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {BN}
  */
 
-utils.read64BE = function read64BE(arr, off) {
+utils.read64BE = function read64BE(data, off) {
   var num;
 
   off = off >>> 0;
 
-  num = arr.slice(off, off + 8);
+  num = data.slice(off, off + 8);
 
   if (num[0] & 0x80)
     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.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @param {Boolean} force53 - Read only 53 bits, but maintain the sign.
  * @returns {Number}
  * @throws on num > MAX_SAFE_INTEGER
  */
 
-utils.readU64N = function readU64N(dst, off, force53) {
+utils.readU64N = function readU64N(data, off, force53) {
   off = off >>> 0;
-  var hi = utils.readU32(dst, off + 4);
-  var lo = utils.readU32(dst, off);
+  var hi = utils.readU32(data, off + 4);
+  var lo = utils.readU32(data, off);
   if (force53)
     hi &= utils.MAX_SAFE_HI;
   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.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @param {Boolean} force53 - Read only 53 bits, but maintain the sign.
  * @returns {Number}
  * @throws on num > MAX_SAFE_INTEGER
  */
 
-utils.readU64NBE = function readU64NBE(dst, off, force53) {
+utils.readU64NBE = function readU64NBE(data, off, force53) {
   off = off >>> 0;
-  var hi = utils.readU32BE(dst, off);
-  var lo = utils.readU32BE(dst, off + 4);
+  var hi = utils.readU32BE(data, off);
+  var lo = utils.readU32BE(data, off + 4);
   if (force53)
     hi &= utils.MAX_SAFE_HI;
   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.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @param {Boolean} force53 - Read only 53 bits, but maintain the sign.
  * @returns {Number}
  * @throws on num > MAX_SAFE_INTEGER
  */
 
-utils.read64N = function read64N(dst, off, force53) {
+utils.read64N = function read64N(data, off, force53) {
   off = off >>> 0;
-  var hi = utils.readU32(dst, off + 4);
-  var lo = utils.readU32(dst, off);
+  var hi = utils.readU32(data, off + 4);
+  var lo = utils.readU32(data, off);
   if (hi & 0x80000000) {
     hi = ~hi + 1;
     lo = ~lo + 1;
@@ -1756,17 +1738,17 @@ utils.read64N = function read64N(dst, off, force53) {
 
 /**
  * Read int64be as a js number.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @param {Boolean} force53 - Read only 53 bits, but maintain the sign.
  * @returns {Number}
  * @throws on num > MAX_SAFE_INTEGER
  */
 
-utils.read64NBE = function read64NBE(dst, off, force53) {
+utils.read64NBE = function read64NBE(data, off, force53) {
   off = off >>> 0;
-  var hi = utils.readU32BE(dst, off);
-  var lo = utils.readU32BE(dst, off + 4);
+  var hi = utils.readU32BE(data, off);
+  var lo = utils.readU32BE(data, off + 4);
   if (hi & 0x80000000) {
     hi = ~hi + 1;
     lo = ~lo + 1;
@@ -1784,49 +1766,49 @@ utils.read64NBE = function read64NBE(dst, off, force53) {
 /**
  * Read first least significant 53 bits of
  * a uint64le as a js number. Maintain the sign.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.readU53 = function readU53(dst, off) {
-  return utils.readU64N(dst, off, true);
+utils.readU53 = function readU53(data, off) {
+  return utils.readU64N(data, off, true);
 };
 
 /**
  * Read first least significant 53 bits of
  * a uint64be as a js number. Maintain the sign.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.readU53BE = function readU53BE(dst, off) {
-  return utils.readU64NBE(dst, off, true);
+utils.readU53BE = function readU53BE(data, off) {
+  return utils.readU64NBE(data, off, true);
 };
 
 /**
  * Read first least significant 53 bits of
  * a uint64le as a js number. Maintain the sign.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.read53 = function read53(dst, off) {
-  return utils.read64N(dst, off, true);
+utils.read53 = function read53(data, off) {
+  return utils.read64N(data, off, true);
 };
 
 /**
  * Read first least significant 53 bits of
  * a int64be as a js number. Maintain the sign.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @returns {Number}
  */
 
-utils.read53BE = function read53BE(dst, off) {
-  return utils.read64NBE(dst, off, true);
+utils.read53BE = function read53BE(data, off) {
+  return utils.read64NBE(data, off, true);
 };
 
 /**
@@ -1974,42 +1956,42 @@ utils.write64BE = function write64BE(dst, num, off) {
 
 /**
  * Read a varint.
- * @param {Buffer} arr
+ * @param {Buffer} data
  * @param {Number} off
  * @param {Boolean?} big - Whether to read as a big number.
  * @returns {Number}
  */
 
-utils.readVarint = function readVarint(arr, off, big) {
+utils.readVarint = function readVarint(data, off, big) {
   var r, bytes;
 
   off = off >>> 0;
 
-  assert(off < arr.length);
+  assert(off < data.length);
 
-  if (arr[off] < 0xfd) {
-    r = arr[off];
+  if (data[off] < 0xfd) {
+    r = data[off];
     if (big)
       r = new bn(r);
     bytes = 1;
-  } else if (arr[off] === 0xfd) {
-    assert(off + 2 < arr.length);
-    r = arr[off + 1] | (arr[off + 2] << 8);
+  } else if (data[off] === 0xfd) {
+    assert(off + 2 < data.length);
+    r = data[off + 1] | (data[off + 2] << 8);
     if (big)
       r = new bn(r);
     bytes = 3;
-  } else if (arr[off] === 0xfe) {
-    assert(off + 4 < arr.length);
-    r = utils.readU32(arr, off + 1);
+  } else if (data[off] === 0xfe) {
+    assert(off + 4 < data.length);
+    r = utils.readU32(data, off + 1);
     if (big)
       r = new bn(r);
     bytes = 5;
-  } else if (arr[off] === 0xff) {
-    assert(off + 8 < arr.length);
+  } else if (data[off] === 0xff) {
+    assert(off + 8 < data.length);
     if (big)
-      r = utils.readU64(arr, off + 1);
+      r = utils.readU64(data, off + 1);
     else
-      r = utils.readU64N(arr, off + 1);
+      r = utils.readU64N(data, off + 1);
     bytes = 9;
   } else {
     assert(false, 'Malformed varint.');
@@ -2227,13 +2209,13 @@ utils.forRange = function forRange(from, to, iter, callback) {
 
 /**
  * Asynchronously iterate over an array in parallel.
- * @param {Array} arr
+ * @param {Array} obj
  * @param {Function} iter
  * @param {Function} callback
  */
 
-utils.forEach = function forEach(arr, iter, callback) {
-  var pending = arr.length;
+utils.forEach = function forEach(obj, iter, callback) {
+  var pending = obj.length;
   var error;
 
   callback = utils.asyncify(callback);
@@ -2249,7 +2231,7 @@ utils.forEach = function forEach(arr, iter, callback) {
       callback(error);
   }
 
-  arr.forEach(function(item, i) {
+  obj.forEach(function(item, i) {
     iter(item, next, i);
   });
 };
@@ -2286,12 +2268,12 @@ utils.forRangeSerial = function forRangeSerial(from, to, iter, callback) {
 
 /**
  * Asynchronously iterate over an array in serial.
- * @param {Array} arr
+ * @param {Array} obj
  * @param {Function} iter
  * @param {Function} callback
  */
 
-utils.forEachSerial = function forEachSerial(arr, iter, callback) {
+utils.forEachSerial = function forEachSerial(obj, iter, callback) {
   var i = 0;
   var called = false;
 
@@ -2304,11 +2286,11 @@ utils.forEachSerial = function forEachSerial(arr, iter, callback) {
       called = true;
       return callback(err);
     }
-    if (i >= arr.length) {
+    if (i >= obj.length) {
       called = true;
       return callback();
     }
-    item = arr[i];
+    item = obj[i];
     i++;
     utils.nextTick(function() {
       iter(item, next, i - 1);
@@ -2319,13 +2301,13 @@ utils.forEachSerial = function forEachSerial(arr, iter, callback) {
 /**
  * Asynchronously apply a truth test to every
  * member of an array in parallel.
- * @param {Array} arr
+ * @param {Array} obj
  * @param {Function} iter
  * @param {Function} callback
  */
 
-utils.every = function every(arr, iter, callback) {
-  var pending = arr.length;
+utils.every = function every(obj, iter, callback) {
+  var pending = obj.length;
   var result = true;
   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);
   });
 };
@@ -2355,12 +2337,12 @@ utils.every = function every(arr, iter, callback) {
 /**
  * Asynchronously apply a truth test to every
  * member of an array in serial.
- * @param {Array} arr
+ * @param {Array} obj
  * @param {Function} iter
  * @param {Function} callback
  */
 
-utils.everySerial = function everySerial(arr, iter, callback) {
+utils.everySerial = function everySerial(obj, iter, callback) {
   var i = 0;
   var called = false;
 
@@ -2377,11 +2359,11 @@ utils.everySerial = function everySerial(arr, iter, callback) {
       called = true;
       return callback(null, false);
     }
-    if (i >= arr.length) {
+    if (i >= obj.length) {
       called = true;
       return callback(null, true);
     }
-    item = arr[i];
+    item = obj[i];
     i++;
     utils.nextTick(function() {
       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.
- * @param {Buffer[]} arr
- * @param {Buffer} buf - Target buffer to find.
+ * @param {Buffer[]} obj
+ * @param {Buffer} data - Target buffer to find.
  * @returns {Number} Index (-1 if not found).
  */
 
-utils.indexOf = function indexOf(arr, buf) {
+utils.indexOf = function indexOf(obj, data) {
   var i;
 
-  assert(Array.isArray(arr));
-  assert(Buffer.isBuffer(buf));
+  assert(Array.isArray(obj));
+  assert(Buffer.isBuffer(data));
 
-  for (i = 0; i < arr.length; i++) {
-    if (!Buffer.isBuffer(arr[i]))
+  for (i = 0; i < obj.length; i++) {
+    if (!Buffer.isBuffer(obj[i]))
       continue;
-    if (utils.equal(arr[i], buf))
+    if (utils.equal(obj[i], data))
       return i;
   }
 
@@ -2695,13 +2677,13 @@ utils.serial = function serial(stack, callback) {
 
 /**
  * Convert an array to a map.
- * @param {String[]} arr
+ * @param {String[]} obj
  * @returns {Object} Map.
  */
 
-utils.toMap = function toMap(arr) {
+utils.toMap = function toMap(obj) {
   var map = {};
-  arr.forEach(function(value) {
+  obj.forEach(function(value) {
     map[value] = true;
   });
   return map;
diff --git a/lib/bcoin/wallet.js b/lib/bcoin/wallet.js
index e624f099..2fdc950c 100644
--- a/lib/bcoin/wallet.js
+++ b/lib/bcoin/wallet.js
@@ -901,7 +901,7 @@ Wallet.prototype.getInputPaths = function getInputPaths(tx, index) {
     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);
   }
 
-  return utils.uniqs(paths);
+  return utils.uniq(paths);
 };
 
 /**