refactor: rename buffer reader/writer vars.

lib/bip70/payment.js

@@ -66,25 +66,25 @@ Payment.prototype.setData = PaymentDetails.prototype.setData;
 Payment.prototype.getData = PaymentDetails.prototype.getData;
 
 Payment.prototype.fromRaw = function fromRaw(data) {
-  var p = new ProtoReader(data);
+  var br = new ProtoReader(data);
   var tx, op, output;
 
-  this.merchantData = p.readFieldBytes(1, true);
+  this.merchantData = br.readFieldBytes(1, true);
 
-  while (p.nextTag() === 2) {
-    tx = TX.fromRaw(p.readFieldBytes(2));
+  while (br.nextTag() === 2) {
+    tx = TX.fromRaw(br.readFieldBytes(2));
     this.transactions.push(tx);
   }
 
-  while (p.nextTag() === 3) {
-    op = new ProtoReader(p.readFieldBytes(3));
+  while (br.nextTag() === 3) {
+    op = new ProtoReader(br.readFieldBytes(3));
     output = new Output();
     output.value = op.readFieldU64(1, true);
     output.script = Script.fromRaw(op.readFieldBytes(2, true));
     this.refundTo.push(output);
   }
 
-  this.memo = p.readFieldString(4, true);
+  this.memo = br.readFieldString(4, true);
 
   return this;
 };
@@ -96,11 +96,11 @@ Payment.fromRaw = function fromRaw(data, enc) {
 };
 
 Payment.prototype.toRaw = function toRaw(writer) {
-  var p = new ProtoWriter(writer);
+  var bw = new ProtoWriter(writer);
   var i, tx, op, output;
 
   if (this.merchantData)
-    p.writeFieldBytes(1, this.merchantData);
+    bw.writeFieldBytes(1, this.merchantData);
 
   for (i = 0; i < this.transactions.length; i++) {
     tx = this.transactions[i];
@@ -112,16 +112,16 @@ Payment.prototype.toRaw = function toRaw(writer) {
     output = this.refundTo[i];
     op.writeFieldU64(1, output.value);
     op.writeFieldBytes(2, output.script.toRaw());
-    p.writeFieldBytes(3, op.render());
+    bw.writeFieldBytes(3, op.render());
   }
 
   if (this.memo != null)
-    p.writeFieldString(4, this.memo);
+    bw.writeFieldString(4, this.memo);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 module.exports = Payment;

lib/bip70/paymentack.js

@@ -40,10 +40,10 @@ PaymentACK.fromOptions = function fromOptions(options) {
 };
 
 PaymentACK.prototype.fromRaw = function fromRaw(data) {
-  var p = new ProtoReader(data);
+  var br = new ProtoReader(data);
 
-  this.payment.fromRaw(p.readFieldBytes(1));
-  this.memo = p.readFieldString(2, true);
+  this.payment.fromRaw(br.readFieldBytes(1));
+  this.memo = br.readFieldString(2, true);
 
   return this;
 };
@@ -55,17 +55,17 @@ PaymentACK.fromRaw = function fromRaw(data, enc) {
 };
 
 PaymentACK.prototype.toRaw = function toRaw(writer) {
-  var p = new ProtoWriter(writer);
+  var bw = new ProtoWriter(writer);
 
-  p.writeFieldBytes(1, this.payment.toRaw());
+  bw.writeFieldBytes(1, this.payment.toRaw());
 
   if (this.memo != null)
-    p.writeFieldString(2, this.memo);
+    bw.writeFieldString(2, this.memo);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 module.exports = PaymentACK;

lib/bip70/paymentdetails.js

@@ -119,24 +119,24 @@ PaymentDetails.prototype.getData = function getData(enc) {
 };
 
 PaymentDetails.prototype.fromRaw = function fromRaw(data) {
-  var p = new ProtoReader(data);
+  var br = new ProtoReader(data);
   var op, output;
 
-  this.network = p.readFieldString(1, true);
+  this.network = br.readFieldString(1, true);
 
-  while (p.nextTag() === 2) {
-    op = new ProtoReader(p.readFieldBytes(2));
+  while (br.nextTag() === 2) {
+    op = new ProtoReader(br.readFieldBytes(2));
     output = new Output();
     output.value = op.readFieldU64(1, true);
     output.script.fromRaw(op.readFieldBytes(2, true));
     this.outputs.push(output);
   }
 
-  this.time = p.readFieldU64(3);
-  this.expires = p.readFieldU64(4, true);
-  this.memo = p.readFieldString(5, true);
-  this.paymentUrl = p.readFieldString(6, true);
-  this.merchantData = p.readFieldBytes(7, true);
+  this.time = br.readFieldU64(3);
+  this.expires = br.readFieldU64(4, true);
+  this.memo = br.readFieldString(5, true);
+  this.paymentUrl = br.readFieldString(6, true);
+  this.merchantData = br.readFieldBytes(7, true);
 
   return this;
 };
@@ -148,38 +148,38 @@ PaymentDetails.fromRaw = function fromRaw(data, enc) {
 };
 
 PaymentDetails.prototype.toRaw = function toRaw(writer) {
-  var p = new ProtoWriter(writer);
+  var bw = new ProtoWriter(writer);
   var i, op, output;
 
   if (this.network != null)
-    p.writeFieldString(1, this.network);
+    bw.writeFieldString(1, this.network);
 
   for (i = 0; i < this.outputs.length; i++) {
     output = this.outputs[i];
     op = new ProtoWriter();
     op.writeFieldU64(1, output.value);
     op.writeFieldBytes(2, output.script.toRaw());
-    p.writeFieldBytes(2, op.render());
+    bw.writeFieldBytes(2, op.render());
   }
 
-  p.writeFieldU64(3, this.time);
+  bw.writeFieldU64(3, this.time);
 
   if (this.expires !== -1)
-    p.writeFieldU64(4, this.expires);
+    bw.writeFieldU64(4, this.expires);
 
   if (this.memo != null)
-    p.writeFieldString(5, this.memo);
+    bw.writeFieldString(5, this.memo);
 
   if (this.paymentUrl != null)
-    p.writeFieldString(6, this.paymentUrl);
+    bw.writeFieldString(6, this.paymentUrl);
 
   if (this.merchantData)
-    p.writeFieldString(7, this.merchantData);
+    bw.writeFieldString(7, this.merchantData);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 module.exports = PaymentDetails;

lib/bip70/paymentrequest.js

@@ -66,13 +66,13 @@ PaymentRequest.fromOptions = function fromOptions(options) {
 };
 
 PaymentRequest.prototype.fromRaw = function fromRaw(data) {
-  var p = new ProtoReader(data);
+  var br = new ProtoReader(data);
 
-  this.version = p.readFieldU32(1, true);
-  this.pkiType = p.readFieldString(2, true);
-  this.pkiData = p.readFieldBytes(3, true);
-  this.paymentDetails.fromRaw(p.readFieldBytes(4));
-  this.signature = p.readFieldBytes(5, true);
+  this.version = br.readFieldU32(1, true);
+  this.pkiType = br.readFieldString(2, true);
+  this.pkiData = br.readFieldBytes(3, true);
+  this.paymentDetails.fromRaw(br.readFieldBytes(4));
+  this.signature = br.readFieldBytes(5, true);
 
   return this;
 };
@@ -84,26 +84,26 @@ PaymentRequest.fromRaw = function fromRaw(data, enc) {
 };
 
 PaymentRequest.prototype.toRaw = function toRaw(writer) {
-  var p = new ProtoWriter(writer);
+  var bw = new ProtoWriter(writer);
 
   if (this.version !== -1)
-    p.writeFieldU32(1, this.version);
+    bw.writeFieldU32(1, this.version);
 
   if (this.pkiType != null)
-    p.writeFieldString(2, this.pkiType);
+    bw.writeFieldString(2, this.pkiType);
 
   if (this.pkiData)
-    p.writeFieldBytes(3, this.pkiData);
+    bw.writeFieldBytes(3, this.pkiData);
 
-  p.writeFieldBytes(4, this.paymentDetails.toRaw());
+  bw.writeFieldBytes(4, this.paymentDetails.toRaw());
 
   if (this.signature)
-    p.writeFieldBytes(5, this.signature);
+    bw.writeFieldBytes(5, this.signature);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 PaymentRequest.prototype.getAlgorithm = function getAlgorithm() {
@@ -146,7 +146,7 @@ PaymentRequest.prototype.signatureHash = function signatureHash() {
 };
 
 PaymentRequest.prototype.setChain = function setChain(chain) {
-  var p = new ProtoWriter();
+  var bw = new ProtoWriter();
   var i, cert, pem;
 
   if (!Array.isArray(chain))
@@ -160,23 +160,23 @@ PaymentRequest.prototype.setChain = function setChain(chain) {
       cert = pem.data;
     }
     assert(Buffer.isBuffer(cert), 'Certificates must be PEM or DER.');
-    p.writeFieldBytes(1, cert);
+    bw.writeFieldBytes(1, cert);
   }
 
-  this.pkiData = p.render();
+  this.pkiData = bw.render();
 };
 
 PaymentRequest.prototype.getChain = function getChain() {
   var chain = [];
-  var p;
+  var br;
 
   if (!this.pkiData)
     return chain;
 
-  p = new ProtoReader(this.pkiData);
+  br = new ProtoReader(this.pkiData);
 
-  while (p.nextTag() === 1)
-    chain.push(p.readFieldBytes(1));
+  while (br.nextTag() === 1)
+    chain.push(br.readFieldBytes(1));
 
   return chain;
 };

lib/blockchain/chaindb.js

@@ -715,16 +715,16 @@ ChainDB.prototype.getCoinView = co(function* getCoinView(block, callback) {
 
 ChainDB.prototype.getUndoCoins = co(function* getUndoCoins(hash) {
   var data = yield this.db.get(layout.u(hash));
-  var p, coins;
+  var br, coins;
 
   if (!data)
     return;
 
-  p = new BufferReader(data);
+  br = new BufferReader(data);
   coins = [];
 
-  while (p.left())
-    coins.push(Coin.fromRaw(p));
+  while (br.left())
+    coins.push(Coin.fromRaw(br));
 
   return coins;
 });
@@ -1921,7 +1921,7 @@ ChainOptions.prototype.verify = function verify(options) {
 };
 
 ChainOptions.prototype.toRaw = function toRaw() {
-  var p = new BufferWriter();
+  var bw = new BufferWriter();
   var flags = 0;
 
   if (this.spv)
@@ -1939,20 +1939,20 @@ ChainOptions.prototype.toRaw = function toRaw() {
   if (this.indexAddress)
     flags |= 1 << 4;
 
-  p.writeU32(this.network.magic);
-  p.writeU32(flags);
-  p.writeU32(0);
+  bw.writeU32(this.network.magic);
+  bw.writeU32(flags);
+  bw.writeU32(0);
 
-  return p.render();
+  return bw.render();
 };
 
 ChainOptions.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
   var flags;
 
-  this.network = Network.fromMagic(p.readU32());
+  this.network = Network.fromMagic(br.readU32());
 
-  flags = p.readU32();
+  flags = br.readU32();
 
   this.spv = (flags & 1) !== 0;
   this.witness = (flags & 2) !== 0;
@@ -2024,21 +2024,21 @@ ChainState.prototype.commit = function commit(hash) {
 };
 
 ChainState.prototype.toRaw = function toRaw() {
-  var p = new BufferWriter();
-  p.writeHash(this.tip);
-  p.writeU64(this.tx);
-  p.writeU64(this.coin);
-  p.writeU64(this.value);
-  return p.render();
+  var bw = new BufferWriter();
+  bw.writeHash(this.tip);
+  bw.writeU64(this.tx);
+  bw.writeU64(this.coin);
+  bw.writeU64(this.value);
+  return bw.render();
 };
 
 ChainState.fromRaw = function fromRaw(data) {
   var state = new ChainState();
-  var p = new BufferReader(data);
-  state.tip = p.readHash();
-  state.tx = p.readU53();
-  state.coin = p.readU53();
-  state.value = p.readU53();
+  var br = new BufferReader(data);
+  state.tip = br.readHash();
+  state.tx = br.readU53();
+  state.coin = br.readU53();
+  state.value = br.readU53();
   return state;
 };
 
@@ -2068,33 +2068,33 @@ StateCache.prototype._init = function _init() {
 };
 
 StateCache.prototype.toDeployments = function toDeployments() {
-  var p = new BufferWriter();
+  var bw = new BufferWriter();
   var i, deployment;
 
-  p.writeU8(this.network.deploys.length);
+  bw.writeU8(this.network.deploys.length);
 
   for (i = 0; i < this.network.deploys.length; i++) {
     deployment = this.network.deploys[i];
-    p.writeU8(deployment.bit);
-    p.writeU32(deployment.startTime);
-    p.writeU32(deployment.timeout);
+    bw.writeU8(deployment.bit);
+    bw.writeU32(deployment.startTime);
+    bw.writeU32(deployment.timeout);
   }
 
-  return p.render();
+  return bw.render();
 };
 
 StateCache.prototype.verifyDeployments = function verifyDeployments(raw) {
-  var p = new BufferReader(raw);
+  var br = new BufferReader(raw);
   var invalid = [];
   var i, count, deployment;
   var bit, start, timeout;
 
-  count = p.readU8();
+  count = br.readU8();
 
   for (i = 0; i < count; i++) {
-    bit = p.readU8();
-    start = p.readU32();
-    timeout = p.readU32();
+    bit = br.readU8();
+    start = br.readU32();
+    timeout = br.readU32();
     deployment = this.network.byBit(bit);
 
     if (deployment

lib/blockchain/chainentry.js

@@ -428,21 +428,21 @@ ChainEntry.fromBlock = function fromBlock(chain, block, prev) {
  */
 
 ChainEntry.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
-  p.writeU32(this.version);
-  p.writeHash(this.prevBlock);
-  p.writeHash(this.merkleRoot);
-  p.writeU32(this.ts);
-  p.writeU32(this.bits);
-  p.writeU32(this.nonce);
-  p.writeU32(this.height);
-  p.writeBytes(this.chainwork.toArrayLike(Buffer, 'le', 32));
+  bw.writeU32(this.version);
+  bw.writeHash(this.prevBlock);
+  bw.writeHash(this.merkleRoot);
+  bw.writeU32(this.ts);
+  bw.writeU32(this.bits);
+  bw.writeU32(this.nonce);
+  bw.writeU32(this.height);
+  bw.writeBytes(this.chainwork.toArrayLike(Buffer, 'le', 32));
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -452,20 +452,20 @@ ChainEntry.prototype.toRaw = function toRaw(writer) {
  */
 
 ChainEntry.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data, true);
-  var hash = crypto.hash256(p.readBytes(80));
+  var br = new BufferReader(data, true);
+  var hash = crypto.hash256(br.readBytes(80));
 
-  p.seek(-80);
+  br.seek(-80);
 
   this.hash = hash.toString('hex');
-  this.version = p.readU32(); // Technically signed
-  this.prevBlock = p.readHash('hex');
-  this.merkleRoot = p.readHash('hex');
-  this.ts = p.readU32();
-  this.bits = p.readU32();
-  this.nonce = p.readU32();
-  this.height = p.readU32();
-  this.chainwork = new BN(p.readBytes(32), 'le');
+  this.version = br.readU32(); // Technically signed
+  this.prevBlock = br.readHash('hex');
+  this.merkleRoot = br.readHash('hex');
+  this.ts = br.readU32();
+  this.bits = br.readU32();
+  this.nonce = br.readU32();
+  this.height = br.readU32();
+  this.chainwork = new BN(br.readBytes(32), 'le');
 
   return this;
 };

lib/blockchain/coins.js

@@ -214,7 +214,7 @@ Coins.prototype.size = function size() {
  */
 
 Coins.prototype.toRaw = function toRaw() {
-  var p = new BufferWriter();
+  var bw = new BufferWriter();
   var length = this.size();
   var len = Math.ceil(length / 8);
   var i, output, bits, start, bit, oct, data;
@@ -225,7 +225,7 @@ Coins.prototype.toRaw = function toRaw() {
 
   // Varint version: hopefully we
   // never run into `-1` versions.
-  p.writeVarint(this.version);
+  bw.writeVarint(this.version);
 
   // Create the `bits` value:
   // (height | coinbase-flag).
@@ -246,14 +246,14 @@ Coins.prototype.toRaw = function toRaw() {
   // lo bit, varints are useless (and
   // actually harmful) after height
   // 32767 (0x7fff).
-  p.writeU32(bits);
+  bw.writeU32(bits);
 
   // Fill the spent field with zeroes to avoid
   // allocating a buffer. We mark the spents
   // after rendering the final buffer.
-  p.writeVarint(len);
-  start = p.written;
-  p.fill(0, len);
+  bw.writeVarint(len);
+  start = bw.written;
+  bw.fill(0, len);
 
   // Write the compressed outputs.
   for (i = 0; i < length; i++) {
@@ -262,12 +262,12 @@ Coins.prototype.toRaw = function toRaw() {
     if (!output)
       continue;
 
-    output.toRaw(p);
+    output.toRaw(bw);
   }
 
   // Render the buffer with all
   // zeroes in the spent field.
-  data = p.render();
+  data = bw.render();
 
   // Mark the spents in the spent field.
   // This is essentially a NOP for new coins.
@@ -295,13 +295,13 @@ Coins.prototype.toRaw = function toRaw() {
  */
 
 Coins.prototype.fromRaw = function fromRaw(data, hash, index) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
   var pos = 0;
   var bits, len, start, bit, oct, spent, coin;
 
-  this.version = p.readVarint();
+  this.version = br.readVarint();
 
-  bits = p.readU32();
+  bits = br.readU32();
 
   this.height = bits >>> 1;
   this.hash = hash;
@@ -309,11 +309,11 @@ Coins.prototype.fromRaw = function fromRaw(data, hash, index) {
 
   // Mark the start of the spent field and
   // seek past it to avoid reading a buffer.
-  len = p.readVarint();
-  start = p.offset;
-  p.seek(len);
+  len = br.readVarint();
+  start = br.offset;
+  br.seek(len);
 
-  while (p.left()) {
+  while (br.left()) {
     bit = pos % 8;
     oct = (pos - bit) / 8;
     oct += start;
@@ -331,7 +331,7 @@ Coins.prototype.fromRaw = function fromRaw(data, hash, index) {
 
     // Store the offset and size
     // in the compressed coin object.
-    coin = CoinEntry.fromRaw(p);
+    coin = CoinEntry.fromRaw(br);
 
     this.outputs.push(coin);
     pos++;
@@ -349,14 +349,14 @@ Coins.prototype.fromRaw = function fromRaw(data, hash, index) {
  */
 
 Coins.parseCoin = function parseCoin(data, hash, index) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
   var coin = new Coin();
   var pos = 0;
   var bits, len, start, bit, oct, spent;
 
-  coin.version = p.readVarint();
+  coin.version = br.readVarint();
 
-  bits = p.readU32();
+  bits = br.readU32();
 
   coin.hash = hash;
   coin.index = index;
@@ -366,11 +366,11 @@ Coins.parseCoin = function parseCoin(data, hash, index) {
 
   // Mark the start of the spent field and
   // seek past it to avoid reading a buffer.
-  len = p.readVarint();
-  start = p.offset;
-  p.seek(len);
+  len = br.readVarint();
+  start = br.offset;
+  br.seek(len);
 
-  while (p.left()) {
+  while (br.left()) {
     bit = pos % 8;
     oct = (pos - bit) / 8;
     oct += start;
@@ -383,8 +383,8 @@ Coins.parseCoin = function parseCoin(data, hash, index) {
     if (pos === index) {
       if (spent)
         return;
-      decompress.script(p, coin.script);
-      coin.value = p.readVarint();
+      decompress.script(br, coin.script);
+      coin.value = br.readVarint();
       return coin;
     }
 
@@ -395,7 +395,7 @@ Coins.parseCoin = function parseCoin(data, hash, index) {
     }
 
     // Skip past the compressed coin.
-    skipCoin(p);
+    skipCoin(br);
     pos++;
   }
 };
@@ -484,7 +484,7 @@ function CoinEntry() {
 
 CoinEntry.prototype.toCoin = function toCoin(coins, index) {
   var coin = new Coin();
-  var p;
+  var br;
 
   // Load in all necessary properties
   // from the parent Coins object.
@@ -500,14 +500,14 @@ CoinEntry.prototype.toCoin = function toCoin(coins, index) {
     return coin;
   }
 
-  p = new BufferReader(this.raw);
+  br = new BufferReader(this.raw);
 
   // Seek to the coin's offset.
-  p.seek(this.offset);
+  br.seek(this.offset);
 
-  decompress.script(p, coin.script);
+  decompress.script(br, coin.script);
 
-  coin.value = p.readVarint();
+  coin.value = br.readVarint();
 
   return coin;
 };
@@ -518,12 +518,12 @@ CoinEntry.prototype.toCoin = function toCoin(coins, index) {
  * @returns {Buffer}
  */
 
-CoinEntry.prototype.toRaw = function toRaw(p) {
+CoinEntry.prototype.toRaw = function toRaw(bw) {
   var raw;
 
   if (this.output) {
-    compress.script(this.output.script, p);
-    p.writeVarint(this.output.value);
+    compress.script(this.output.script, bw);
+    bw.writeVarint(this.output.value);
     return;
   }
 
@@ -535,20 +535,20 @@ CoinEntry.prototype.toRaw = function toRaw(p) {
   // as a buffer for speed.
   raw = this.raw.slice(this.offset, this.offset + this.size);
 
-  p.writeBytes(raw);
+  bw.writeBytes(raw);
 };
 
 /**
  * Instantiate compressed coin from reader.
- * @param {BufferReader} p
+ * @param {BufferReader} br
  * @returns {CoinEntry}
  */
 
-CoinEntry.fromRaw = function fromRaw(p) {
+CoinEntry.fromRaw = function fromRaw(br) {
   var coin = new CoinEntry();
-  coin.offset = p.offset;
-  coin.size = skipCoin(p);
-  coin.raw = p.data;
+  coin.offset = br.offset;
+  coin.size = skipCoin(br);
+  coin.raw = br.data;
   return coin;
 };
 
@@ -583,29 +583,29 @@ CoinEntry.fromCoin = function fromCoin(coin) {
  * Helpers
  */
 
-function skipCoin(p) {
-  var start = p.offset;
+function skipCoin(br) {
+  var start = br.offset;
 
   // Skip past the compressed scripts.
-  switch (p.readU8()) {
+  switch (br.readU8()) {
     case 0:
-      p.seek(p.readVarint());
+      br.seek(br.readVarint());
       break;
     case 1:
     case 2:
-      p.seek(20);
+      br.seek(20);
       break;
     case 3:
-      p.seek(33);
+      br.seek(33);
       break;
     default:
       throw new Error('Bad prefix.');
   }
 
   // Skip past the value.
-  p.skipVarint();
+  br.skipVarint();
 
-  return p.offset - start;
+  return br.offset - start;
 }
 
 /*

lib/blockchain/compress.js

@@ -16,10 +16,10 @@ var ec = require('../crypto/ec');
 /**
  * Compress a script, write directly to the buffer.
  * @param {Script} script
- * @param {BufferWriter} p
+ * @param {BufferWriter} bw
  */
 
-function compressScript(script, p) {
+function compressScript(script, bw) {
   var prefix = 0;
   var data;
 
@@ -47,38 +47,38 @@ function compressScript(script, p) {
       prefix = 0;
   }
 
-  p.writeU8(prefix);
+  bw.writeU8(prefix);
 
   if (prefix === 0)
-    p.writeVarBytes(script.toRaw());
+    bw.writeVarBytes(script.toRaw());
   else
-    p.writeBytes(data);
+    bw.writeBytes(data);
 }
 
 /**
  * Decompress a script from buffer reader.
- * @param {BufferReader} p
+ * @param {BufferReader} br
  * @param {Script} script
  */
 
-function decompressScript(p, script) {
+function decompressScript(br, script) {
   var key;
 
   // Decompress the script.
-  switch (p.readU8()) {
+  switch (br.readU8()) {
     case 0:
-      script.fromRaw(p.readVarBytes());
+      script.fromRaw(br.readVarBytes());
       break;
     case 1:
-      script.fromPubkeyhash(p.readBytes(20));
+      script.fromPubkeyhash(br.readBytes(20));
       break;
     case 2:
-      script.fromScripthash(p.readBytes(20));
+      script.fromScripthash(br.readBytes(20));
       break;
     case 3:
       // Decompress the key. If this fails,
       // we have database corruption!
-      key = decompressKey(p.readBytes(33));
+      key = decompressKey(br.readBytes(33));
       script.fromPubkey(key);
       break;
     default:

lib/hd/mnemonic.js

@@ -419,21 +419,21 @@ Mnemonic.fromJSON = function fromJSON(json) {
  */
 
 Mnemonic.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
   var lang = Mnemonic.languages.indexOf(this.language);
 
   assert(lang !== -1);
 
-  p.writeU16(this.bits);
-  p.writeU8(lang);
-  p.writeBytes(this.getEntropy());
-  p.writeVarString(this.getPhrase(), 'utf8');
-  p.writeVarString(this.passphrase, 'utf8');
+  bw.writeU16(this.bits);
+  bw.writeU8(lang);
+  bw.writeBytes(this.getEntropy());
+  bw.writeVarString(this.getPhrase(), 'utf8');
+  bw.writeVarString(this.passphrase, 'utf8');
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -443,13 +443,13 @@ Mnemonic.prototype.toRaw = function toRaw(writer) {
  */
 
 Mnemonic.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
 
-  this.bits = p.readU16();
-  this.language = Mnemonic.languages[p.readU8()];
-  this.entropy = p.readBytes(this.bits / 8);
-  this.phrase = p.readVarString('utf8');
-  this.passphrase = p.readVarString('utf8');
+  this.bits = br.readU16();
+  this.language = Mnemonic.languages[br.readU8()];
+  this.entropy = br.readBytes(this.bits / 8);
+  this.phrase = br.readVarString('utf8');
+  this.passphrase = br.readVarString('utf8');
 
   assert(this.language);
   assert(this.bits >= constants.hd.MIN_ENTROPY);

lib/hd/private.js

@@ -192,7 +192,7 @@ HDPrivateKey.prototype.destroy = function destroy(pub) {
  */
 
 HDPrivateKey.prototype.derive = function derive(index, hardened, cache) {
-  var p, id, data, hash, left, right, key, child;
+  var bw, id, data, hash, left, right, key, child;
 
   if (typeof hardened !== 'boolean') {
     cache = hardened;
@@ -223,18 +223,18 @@ HDPrivateKey.prototype.derive = function derive(index, hardened, cache) {
       return child;
   }
 
-  p = new BufferWriter();
+  bw = new BufferWriter();
 
   if (hardened) {
-    p.writeU8(0);
-    p.writeBytes(this.privateKey);
-    p.writeU32BE(index);
+    bw.writeU8(0);
+    bw.writeBytes(this.privateKey);
+    bw.writeU32BE(index);
   } else {
-    p.writeBytes(this.publicKey);
-    p.writeU32BE(index);
+    bw.writeBytes(this.publicKey);
+    bw.writeU32BE(index);
   }
 
-  data = p.render();
+  data = bw.render();
 
   hash = crypto.hmac('sha512', data, this.chainCode);
   left = hash.slice(0, 32);
@@ -613,17 +613,17 @@ HDPrivateKey.prototype.fromBase58 = function fromBase58(xkey) {
  */
 
 HDPrivateKey.prototype.fromRaw = function fromRaw(raw) {
-  var p = new BufferReader(raw);
+  var br = new BufferReader(raw);
   var i, version, type, prefix;
 
-  version = p.readU32BE();
-  this.depth = p.readU8();
-  this.parentFingerPrint = p.readBytes(4);
-  this.childIndex = p.readU32BE();
-  this.chainCode = p.readBytes(32);
-  p.readU8();
-  this.privateKey = p.readBytes(32);
-  p.verifyChecksum();
+  version = br.readU32BE();
+  this.depth = br.readU8();
+  this.parentFingerPrint = br.readBytes(4);
+  this.childIndex = br.readU32BE();
+  this.chainCode = br.readBytes(32);
+  br.readU8();
+  this.privateKey = br.readBytes(32);
+  br.verifyChecksum();
 
   for (i = 0; i < networks.types.length; i++) {
     type = networks.types[i];
@@ -657,26 +657,26 @@ HDPrivateKey.prototype.toBase58 = function toBase58(network) {
  */
 
 HDPrivateKey.prototype.toRaw = function toRaw(network, writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
   if (!network)
     network = this.network;
 
   network = Network.get(network);
 
-  p.writeU32BE(network.keyPrefix.xprivkey);
-  p.writeU8(this.depth);
-  p.writeBytes(this.parentFingerPrint);
-  p.writeU32BE(this.childIndex);
-  p.writeBytes(this.chainCode);
-  p.writeU8(0);
-  p.writeBytes(this.privateKey);
-  p.writeChecksum();
+  bw.writeU32BE(network.keyPrefix.xprivkey);
+  bw.writeU8(this.depth);
+  bw.writeBytes(this.parentFingerPrint);
+  bw.writeU32BE(this.childIndex);
+  bw.writeBytes(this.chainCode);
+  bw.writeU8(0);
+  bw.writeBytes(this.privateKey);
+  bw.writeChecksum();
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -687,21 +687,21 @@ HDPrivateKey.prototype.toRaw = function toRaw(network, writer) {
  */
 
 HDPrivateKey.prototype.toExtended = function toExtended(network, writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
-  this.toRaw(network, p);
+  this.toRaw(network, bw);
 
   if (this.mnemonic) {
-    p.writeU8(1);
-    this.mnemonic.toRaw(p);
+    bw.writeU8(1);
+    this.mnemonic.toRaw(bw);
   } else {
-    p.writeU8(0);
+    bw.writeU8(0);
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -711,10 +711,10 @@ HDPrivateKey.prototype.toExtended = function toExtended(network, writer) {
  */
 
 HDPrivateKey.prototype.fromExtended = function fromExtended(data) {
-  var p = new BufferReader(data);
-  this.fromRaw(p);
-  if (p.readU8() === 1)
-    this.mnemonic = Mnemonic.fromRaw(p);
+  var br = new BufferReader(data);
+  this.fromRaw(br);
+  if (br.readU8() === 1)
+    this.mnemonic = Mnemonic.fromRaw(br);
   return this;
 };
 

lib/hd/public.js

@@ -143,7 +143,7 @@ HDPublicKey.prototype.destroy = function destroy() {
  */
 
 HDPublicKey.prototype.derive = function derive(index, hardened, cache) {
-  var p, id, data, hash, left, right, key, child;
+  var bw, id, data, hash, left, right, key, child;
 
   if (typeof hardened !== 'boolean') {
     cache = hardened;
@@ -172,10 +172,10 @@ HDPublicKey.prototype.derive = function derive(index, hardened, cache) {
       return child;
   }
 
-  p = new BufferWriter();
-  p.writeBytes(this.publicKey);
-  p.writeU32BE(index);
-  data = p.render();
+  bw = new BufferWriter();
+  bw.writeBytes(this.publicKey);
+  bw.writeU32BE(index);
+  data = bw.render();
 
   hash = crypto.hmac('sha512', data, this.chainCode);
   left = hash.slice(0, 32);
@@ -467,16 +467,16 @@ HDPublicKey.prototype.fromBase58 = function fromBase58(xkey) {
  */
 
 HDPublicKey.prototype.fromRaw = function fromRaw(raw) {
-  var p = new BufferReader(raw);
+  var br = new BufferReader(raw);
   var i, version, type, prefix;
 
-  version = p.readU32BE();
-  this.depth = p.readU8();
-  this.parentFingerPrint = p.readBytes(4);
-  this.childIndex = p.readU32BE();
-  this.chainCode = p.readBytes(32);
-  this.publicKey = p.readBytes(33);
-  p.verifyChecksum();
+  version = br.readU32BE();
+  this.depth = br.readU8();
+  this.parentFingerPrint = br.readBytes(4);
+  this.childIndex = br.readU32BE();
+  this.chainCode = br.readBytes(32);
+  this.publicKey = br.readBytes(33);
+  br.verifyChecksum();
 
   for (i = 0; i < networks.types.length; i++) {
     type = networks.types[i];
@@ -509,25 +509,25 @@ HDPublicKey.prototype.toBase58 = function toBase58(network) {
  */
 
 HDPublicKey.prototype.toRaw = function toRaw(network, writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
   if (!network)
     network = this.network;
 
   network = Network.get(network);
 
-  p.writeU32BE(network.keyPrefix.xpubkey);
-  p.writeU8(this.depth);
-  p.writeBytes(this.parentFingerPrint);
-  p.writeU32BE(this.childIndex);
-  p.writeBytes(this.chainCode);
-  p.writeBytes(this.publicKey);
-  p.writeChecksum();
+  bw.writeU32BE(network.keyPrefix.xpubkey);
+  bw.writeU8(this.depth);
+  bw.writeBytes(this.parentFingerPrint);
+  bw.writeU32BE(this.childIndex);
+  bw.writeBytes(this.chainCode);
+  bw.writeBytes(this.publicKey);
+  bw.writeChecksum();
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**

lib/http/rpc.js

@@ -2146,7 +2146,7 @@ RPC.prototype.sendrawtransaction = function sendrawtransaction(args) {
 };
 
 RPC.prototype.signrawtransaction = co(function* signrawtransaction(args) {
-  var raw, p, txs, merged;
+  var raw, br, txs, merged;
 
   if (args.help || args.length < 1 || args.length > 4) {
     throw new RPCError('signrawtransaction'
@@ -2160,11 +2160,11 @@ RPC.prototype.signrawtransaction = co(function* signrawtransaction(args) {
     throw new RPCError('Invalid parameter');
 
   raw = new Buffer(args[0], 'hex');
-  p = new BufferReader(raw);
+  br = new BufferReader(raw);
   txs = [];
 
-  while (p.left())
-    txs.push(MTX.fromRaw(p));
+  while (br.left())
+    txs.push(MTX.fromRaw(br));
 
   merged = txs[0];
 

lib/mempool/fees.js

@@ -321,31 +321,31 @@ ConfirmStats.prototype.removeTX = function removeTX(entryHeight, bestHeight, buc
  */
 
 ConfirmStats.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
   var i;
 
   function writeArray(buckets) {
     var i;
 
-    p.writeVarint(buckets.length);
+    bw.writeVarint(buckets.length);
 
     for (i = 0; i < buckets.length; i++)
-      p.writeDouble(buckets[i]);
+      bw.writeDouble(buckets[i]);
   }
 
-  p.writeDouble(this.decay);
+  bw.writeDouble(this.decay);
   writeArray(this.buckets);
   writeArray(this.avg);
   writeArray(this.txAvg);
-  p.writeVarint(this.maxConfirms);
+  bw.writeVarint(this.maxConfirms);
 
   for (i = 0; i < this.maxConfirms; i++)
     writeArray(this.confAvg[i]);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -356,24 +356,24 @@ ConfirmStats.prototype.toRaw = function toRaw(writer) {
  */
 
 ConfirmStats.fromRaw = function fromRaw(data, type, logger) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
   var i, decay, buckets, avg, txAvg, maxConfirms, confAvg, stats;
 
   function readArray() {
-    var buckets = new Float64Array(p.readVarint());
+    var buckets = new Float64Array(br.readVarint());
     var i;
 
     for (i = 0; i < buckets.length; i++)
-      buckets[i] = p.readDouble();
+      buckets[i] = br.readDouble();
 
     return buckets;
   }
 
-  decay = p.readDouble();
+  decay = br.readDouble();
   buckets = readArray();
   avg = readArray();
   txAvg = readArray();
-  maxConfirms = p.readVarint();
+  maxConfirms = br.readVarint();
   confAvg = new Array(maxConfirms);
 
   for (i = 0; i < maxConfirms; i++)
@@ -806,17 +806,17 @@ PolicyEstimator.prototype.estimatePriority = function estimatePriority(target, s
  */
 
 PolicyEstimator.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
-  p.writeU32(this.network.magic);
-  p.writeU32(this.bestHeight);
-  p.writeVarBytes(this.feeStats.toRaw());
-  p.writeVarBytes(this.priStats.toRaw());
+  bw.writeU32(this.network.magic);
+  bw.writeU32(this.bestHeight);
+  bw.writeVarBytes(this.feeStats.toRaw());
+  bw.writeVarBytes(this.priStats.toRaw());
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -828,12 +828,12 @@ PolicyEstimator.prototype.toRaw = function toRaw(writer) {
  */
 
 PolicyEstimator.fromRaw = function fromRaw(minRelay, data, logger) {
-  var p = new BufferReader(data);
-  var network = Network.fromMagic(p.readU32());
-  var bestHeight = p.readU32();
+  var br = new BufferReader(data);
+  var network = Network.fromMagic(br.readU32());
+  var bestHeight = br.readU32();
   var estimator = new PolicyEstimator(minRelay, network, logger);
-  var feeStats = ConfirmStats.fromRaw(p.readVarBytes(), 'FeeRate', logger);
-  var priStats = ConfirmStats.fromRaw(p.readVarBytes(), 'Priority', logger);
+  var feeStats = ConfirmStats.fromRaw(br.readVarBytes(), 'FeeRate', logger);
+  var priStats = ConfirmStats.fromRaw(br.readVarBytes(), 'Priority', logger);
 
   estimator.bestHeight = bestHeight;
   estimator.feeStats = feeStats;

lib/net/bip150.js

@@ -282,12 +282,12 @@ BIP150.prototype.getAddress = function getAddress() {
 };
 
 BIP150.address = function address(key) {
-  var p = new BufferWriter();
-  p.writeU8(0x0f);
-  p.writeU16BE(0xff01);
-  p.writeBytes(crypto.hash160(key));
-  p.writeChecksum();
-  return base58.encode(p.render());
+  var bw = new BufferWriter();
+  bw.writeU8(0x0f);
+  bw.writeU16BE(0xff01);
+  bw.writeBytes(crypto.hash160(key));
+  bw.writeChecksum();
+  return base58.encode(bw.render());
 };
 
 /**

lib/net/bip151.js

@@ -89,15 +89,15 @@ function BIP151Stream(cipher) {
  */
 
 BIP151Stream.prototype.init = function init(publicKey) {
-  var p = new BufferWriter();
+  var bw = new BufferWriter();
 
   this.publicKey = publicKey;
   this.secret = ec.ecdh(this.publicKey, this.privateKey);
 
-  p.writeBytes(this.secret);
-  p.writeU8(this.cipher);
+  bw.writeBytes(this.secret);
+  bw.writeU8(this.cipher);
 
-  this.prk = crypto.hkdfExtract(p.render(), HKDF_SALT, 'sha256');
+  this.prk = crypto.hkdfExtract(bw.render(), HKDF_SALT, 'sha256');
   this.k1 = crypto.hkdfExpand(this.prk, INFO_KEY1, 32, 'sha256');
   this.k2 = crypto.hkdfExpand(this.prk, INFO_KEY2, 32, 'sha256');
   this.sid = crypto.hkdfExpand(this.prk, INFO_SID, 32, 'sha256');
@@ -525,14 +525,14 @@ BIP151.prototype.maybeRekey = function maybeRekey(data) {
  */
 
 BIP151.prototype.packet = function packet(cmd, body) {
-  var p = new BufferWriter();
+  var bw = new BufferWriter();
   var payload, packet;
 
-  p.writeVarString(cmd, 'ascii');
-  p.writeU32(body.length);
-  p.writeBytes(body);
+  bw.writeVarString(cmd, 'ascii');
+  bw.writeU32(body.length);
+  bw.writeBytes(body);
 
-  payload = p.render();
+  payload = bw.render();
 
   packet = new Buffer(4 + payload.length + 16);
 
@@ -623,7 +623,7 @@ BIP151.prototype.read = function read(size) {
  */
 
 BIP151.prototype.parse = function parse(data) {
-  var size, payload, tag, p, cmd, body;
+  var size, payload, tag, br, cmd, body;
 
   if (!this.hasSize) {
     size = this.input.decryptSize(data);
@@ -667,12 +667,12 @@ BIP151.prototype.parse = function parse(data) {
   this.input.decrypt(payload);
   this.input.sequence();
 
-  p = new BufferReader(payload);
+  br = new BufferReader(payload);
 
-  while (p.left()) {
+  while (br.left()) {
     try {
-      cmd = p.readVarString('ascii');
-      body = p.readBytes(p.readU32());
+      cmd = br.readVarString('ascii');
+      body = br.readBytes(br.readU32());
     } catch (e) {
       this.emit('error', e);
       return;

lib/net/bip152.js

@@ -87,36 +87,36 @@ CompactBlock.fromOptions = function fromOptions(options) {
 };
 
 CompactBlock.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
   var i, count, index, tx;
 
-  this.version = p.readU32(); // Technically signed
-  this.prevBlock = p.readHash('hex');
-  this.merkleRoot = p.readHash('hex');
-  this.ts = p.readU32();
-  this.bits = p.readU32();
-  this.nonce = p.readU32();
+  this.version = br.readU32(); // Technically signed
+  this.prevBlock = br.readHash('hex');
+  this.merkleRoot = br.readHash('hex');
+  this.ts = br.readU32();
+  this.bits = br.readU32();
+  this.nonce = br.readU32();
 
-  this.keyNonce = p.readBytes(8);
+  this.keyNonce = br.readBytes(8);
 
   this.initKey();
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   this.totalTX += count;
 
   for (i = 0; i < count; i++)
-    this.ids.push(p.readU32() + p.readU16() * 0x100000000);
+    this.ids.push(br.readU32() + br.readU16() * 0x100000000);
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   this.totalTX += count;
 
   for (i = 0; i < count; i++) {
-    index = p.readVarint();
+    index = br.readVarint();
     assert(index <= 0xffff);
     assert(index < this.totalTX);
-    tx = TX.fromRaw(p);
+    tx = TX.fromRaw(br);
     this.ptx.push([index, tx]);
   }
 
@@ -140,44 +140,44 @@ CompactBlock.prototype.toNormal = function toNormal(writer) {
 };
 
 CompactBlock.prototype.frame = function frame(witness, writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i, id, lo, hi, ptx;
 
-  p.writeU32(this.version);
-  p.writeHash(this.prevBlock);
-  p.writeHash(this.merkleRoot);
-  p.writeU32(this.ts);
-  p.writeU32(this.bits);
-  p.writeU32(this.nonce);
+  bw.writeU32(this.version);
+  bw.writeHash(this.prevBlock);
+  bw.writeHash(this.merkleRoot);
+  bw.writeU32(this.ts);
+  bw.writeU32(this.bits);
+  bw.writeU32(this.nonce);
 
-  p.writeBytes(this.keyNonce);
+  bw.writeBytes(this.keyNonce);
 
-  p.writeVarint(this.ids.length);
+  bw.writeVarint(this.ids.length);
 
   for (i = 0; i < this.ids.length; i++) {
     id = this.ids[i];
     lo = id % 0x100000000;
     hi = (id - lo) / 0x100000000;
     hi &= 0xffff;
-    p.writeU32(lo);
-    p.writeU16(hi);
+    bw.writeU32(lo);
+    bw.writeU16(hi);
   }
 
-  p.writeVarint(this.ptx.length);
+  bw.writeVarint(this.ptx.length);
 
   for (i = 0; i < this.ptx.length; i++) {
     ptx = this.ptx[i];
-    p.writeVarint(ptx[0]);
+    bw.writeVarint(ptx[0]);
     if (witness)
-      ptx[1].toRaw(p);
+      ptx[1].toRaw(bw);
     else
-      ptx[1].toNormal(p);
+      ptx[1].toNormal(bw);
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 CompactBlock.prototype.toRequest = function toRequest() {
@@ -456,15 +456,15 @@ TXRequest.fromCompact = function fromCompact(block) {
 };
 
 TXRequest.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, count, index, offset;
 
-  this.hash = p.readHash('hex');
+  this.hash = br.readHash('hex');
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++) {
-    index = p.readVarint();
+    index = br.readVarint();
     assert(index <= 0xffff);
     this.indexes.push(index);
   }
@@ -487,22 +487,22 @@ TXRequest.fromRaw = function fromRaw(data) {
 };
 
 TXRequest.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i, index;
 
-  p.writeHash(this.hash);
+  bw.writeHash(this.hash);
 
-  p.writeVarint(this.indexes.length);
+  bw.writeVarint(this.indexes.length);
 
   for (i = 0; i < this.indexes.length; i++) {
     index = this.indexes[i] - (i === 0 ? 0 : this.indexes[i - 1] + 1);
-    p.writeVarint(index);
+    bw.writeVarint(index);
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -536,15 +536,15 @@ TXResponse.fromOptions = function fromOptions(options) {
 };
 
 TXResponse.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, count;
 
-  this.hash = p.readHash('hex');
+  this.hash = br.readHash('hex');
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.txs.push(TX.fromRaw(p));
+    this.txs.push(TX.fromRaw(br));
 
   return this;
 };
@@ -581,25 +581,25 @@ TXResponse.prototype.toNormal = function toNormal(writer) {
 };
 
 TXResponse.prototype.frame = function frame(witness, writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i, tx;
 
-  p.writeHash(this.hash);
+  bw.writeHash(this.hash);
 
-  p.writeVarint(this.txs.length);
+  bw.writeVarint(this.txs.length);
 
   for (i = 0; i < this.txs.length; i++) {
     tx = this.txs[i];
     if (witness)
-      tx.toRaw(p);
+      tx.toRaw(bw);
     else
-      tx.toNormal(p);
+      tx.toNormal(bw);
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /*

lib/net/packets.js

@@ -188,22 +188,22 @@ VersionPacket.fromOptions = function fromOptions(options) {
  */
 
 VersionPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.write32(this.version);
-  p.writeU64(this.services);
-  p.write64(this.ts);
-  this.recv.toRaw(false, p);
-  this.from.toRaw(false, p);
-  p.writeBytes(this.nonce);
-  p.writeVarString(this.agent, 'ascii');
-  p.write32(this.height);
-  p.writeU8(this.relay ? 1 : 0);
+  bw.write32(this.version);
+  bw.writeU64(this.services);
+  bw.write64(this.ts);
+  this.recv.toRaw(false, bw);
+  this.from.toRaw(false, bw);
+  bw.writeBytes(this.nonce);
+  bw.writeVarString(this.agent, 'ascii');
+  bw.write32(this.height);
+  bw.writeU8(this.relay ? 1 : 0);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -268,26 +268,26 @@ VersionPacket.prototype.hasCompact = function hasCompact() {
  */
 
 VersionPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
 
-  this.version = p.read32();
-  this.services = p.readU53();
-  this.ts = p.read53();
-  this.recv.fromRaw(p, false);
+  this.version = br.read32();
+  this.services = br.readU53();
+  this.ts = br.read53();
+  this.recv.fromRaw(br, false);
 
-  if (p.left() > 0) {
-    this.from.fromRaw(p, false);
-    this.nonce = p.readBytes(8);
+  if (br.left() > 0) {
+    this.from.fromRaw(br, false);
+    this.nonce = br.readBytes(8);
   }
 
-  if (p.left() > 0)
-    this.agent = p.readVarString('ascii', 256);
+  if (br.left() > 0)
+    this.agent = br.readVarString('ascii', 256);
 
-  if (p.left() > 0)
-    this.height = p.read32();
+  if (br.left() > 0)
+    this.height = br.read32();
 
-  if (p.left() > 0)
-    this.relay = p.readU8() === 1;
+  if (br.left() > 0)
+    this.relay = br.readU8() === 1;
 
   if (this.version === 10300)
     this.version = 300;
@@ -388,15 +388,15 @@ PingPacket.prototype.type = exports.types.PING;
  */
 
 PingPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
   if (this.nonce)
-    p.writeBytes(this.nonce);
+    bw.writeBytes(this.nonce);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -406,9 +406,9 @@ PingPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 PingPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  if (p.left() >= 8)
-    this.nonce = p.readBytes(8);
+  var br = BufferReader(data);
+  if (br.left() >= 8)
+    this.nonce = br.readBytes(8);
   return this;
 };
 
@@ -453,14 +453,14 @@ PongPacket.prototype.type = exports.types.PONG;
  */
 
 PongPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeBytes(this.nonce);
+  bw.writeBytes(this.nonce);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -470,8 +470,8 @@ PongPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 PongPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.nonce = p.readBytes(8);
+  var br = BufferReader(data);
+  this.nonce = br.readBytes(8);
   return this;
 };
 
@@ -656,15 +656,15 @@ AlertPacket.prototype.verify = function verify(key) {
  */
 
 AlertPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeVarBytes(this.toPayload());
-  p.writeVarBytes(this.signature);
+  bw.writeVarBytes(this.toPayload());
+  bw.writeVarBytes(this.signature);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -674,35 +674,35 @@ AlertPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 AlertPacket.prototype.framePayload = function framePayload(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i;
 
-  p.write32(this.version);
-  p.write64(this.relayUntil);
-  p.write64(this.expiration);
-  p.write32(this.id);
-  p.write32(this.cancel);
+  bw.write32(this.version);
+  bw.write64(this.relayUntil);
+  bw.write64(this.expiration);
+  bw.write32(this.id);
+  bw.write32(this.cancel);
 
-  p.writeVarint(this.cancels.length);
+  bw.writeVarint(this.cancels.length);
   for (i = 0; i < this.cancels.length; i++)
-    p.write32(this.cancels[i]);
+    bw.write32(this.cancels[i]);
 
-  p.write32(this.minVer);
-  p.write32(this.maxVer);
+  bw.write32(this.minVer);
+  bw.write32(this.maxVer);
 
-  p.writeVarint(this.subVers.length);
+  bw.writeVarint(this.subVers.length);
   for (i = 0; i < this.subVers.length; i++)
-    p.writeVarString(this.subVers[i], 'ascii');
+    bw.writeVarString(this.subVers[i], 'ascii');
 
-  p.write32(this.priority);
-  p.writeVarString(this.comment, 'ascii');
-  p.writeVarString(this.statusBar, 'ascii');
-  p.writeVarString(this.reserved, 'ascii');
+  bw.write32(this.priority);
+  bw.writeVarString(this.comment, 'ascii');
+  bw.writeVarString(this.statusBar, 'ascii');
+  bw.writeVarString(this.reserved, 'ascii');
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -712,35 +712,35 @@ AlertPacket.prototype.framePayload = function framePayload(writer) {
  */
 
 AlertPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, count;
 
-  this._payload = p.readVarBytes();
-  this.signature = p.readVarBytes();
+  this._payload = br.readVarBytes();
+  this.signature = br.readVarBytes();
 
-  p = BufferReader(this._payload);
+  br = BufferReader(this._payload);
 
-  this.version = p.read32();
-  this.relayUntil = p.read53();
-  this.expiration = p.read53();
-  this.id = p.read32();
-  this.cancel = p.read32();
+  this.version = br.read32();
+  this.relayUntil = br.read53();
+  this.expiration = br.read53();
+  this.id = br.read32();
+  this.cancel = br.read32();
 
-  count = p.readVarint();
+  count = br.readVarint();
   for (i = 0; i < count; i++)
-    this.cancels.push(p.read32());
+    this.cancels.push(br.read32());
 
-  this.minVer = p.read32();
-  this.maxVer = p.read32();
+  this.minVer = br.read32();
+  this.maxVer = br.read32();
 
-  count = p.readVarint();
+  count = br.readVarint();
   for (i = 0; i < count; i++)
-    this.subVers.push(p.readVarString('ascii'));
+    this.subVers.push(br.readVarString('ascii'));
 
-  this.priority = p.read32();
-  this.comment = p.readVarString('ascii');
-  this.statusBar = p.readVarString('ascii');
-  this.reserved = p.readVarString('ascii');
+  this.priority = br.read32();
+  this.comment = br.readVarString('ascii');
+  this.statusBar = br.readVarString('ascii');
+  this.reserved = br.readVarString('ascii');
 
   return this;
 };
@@ -836,18 +836,18 @@ AddrPacket.prototype.type = exports.types.ADDR;
  */
 
 AddrPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i;
 
-  p.writeVarint(this.items.length);
+  bw.writeVarint(this.items.length);
 
   for (i = 0; i < this.items.length; i++)
-    this.items[i].toRaw(true, p);
+    this.items[i].toRaw(true, bw);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -857,13 +857,13 @@ AddrPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 AddrPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, count;
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.items.push(NetworkAddress.fromRaw(p, true));
+    this.items.push(NetworkAddress.fromRaw(br, true));
 
   return this;
 };
@@ -909,18 +909,18 @@ InvPacket.prototype.type = exports.types.INV;
  */
 
 InvPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i;
 
-  p.writeVarint(this.items.length);
+  bw.writeVarint(this.items.length);
 
   for (i = 0; i < this.items.length; i++)
-    this.items[i].toRaw(p);
+    this.items[i].toRaw(bw);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -930,13 +930,13 @@ InvPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 InvPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, count;
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.items.push(InvItem.fromRaw(p));
+    this.items.push(InvItem.fromRaw(br));
 
   return this;
 };
@@ -1052,21 +1052,21 @@ GetBlocksPacket.prototype.type = exports.types.GETBLOCKS;
  */
 
 GetBlocksPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i;
 
-  p.writeU32(this.version);
-  p.writeVarint(this.locator.length);
+  bw.writeU32(this.version);
+  bw.writeVarint(this.locator.length);
 
   for (i = 0; i < this.locator.length; i++)
-    p.writeHash(this.locator[i]);
+    bw.writeHash(this.locator[i]);
 
-  p.writeHash(this.stop || constants.ZERO_HASH);
+  bw.writeHash(this.stop || constants.ZERO_HASH);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -1076,17 +1076,17 @@ GetBlocksPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 GetBlocksPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, count;
 
-  this.version = p.readU32();
+  this.version = br.readU32();
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.locator.push(p.readHash('hex'));
+    this.locator.push(br.readHash('hex'));
 
-  this.stop = p.readHash('hex');
+  this.stop = br.readHash('hex');
 
   if (this.stop === constants.NULL_HASH)
     this.stop = null;
@@ -1169,18 +1169,18 @@ HeadersPacket.prototype.type = exports.types.HEADERS;
  */
 
 HeadersPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i;
 
-  p.writeVarint(this.items.length);
+  bw.writeVarint(this.items.length);
 
   for (i = 0; i < this.items.length; i++)
-    this.items[i].toRaw(p);
+    this.items[i].toRaw(bw);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -1190,13 +1190,13 @@ HeadersPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 HeadersPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, count;
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.items.push(Headers.fromRaw(p));
+    this.items.push(Headers.fromRaw(br));
 
   return this;
 };
@@ -1462,22 +1462,22 @@ RejectPacket.fromOptions = function fromOptions(options) {
  */
 
 RejectPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
   assert(this.message.length <= 12);
   assert(this.reason.length <= 111);
 
-  p.writeVarString(this.message, 'ascii');
-  p.writeU8(this.code);
-  p.writeVarString(this.reason, 'ascii');
+  bw.writeVarString(this.message, 'ascii');
+  bw.writeU8(this.code);
+  bw.writeVarString(this.reason, 'ascii');
 
   if (this.data)
-    p.writeHash(this.data);
+    bw.writeHash(this.data);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -1487,14 +1487,14 @@ RejectPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 RejectPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
 
-  this.message = p.readVarString('ascii', 12);
-  this.code = p.readU8();
-  this.reason = p.readVarString('ascii', 111);
+  this.message = br.readVarString('ascii', 12);
+  this.code = br.readU8();
+  this.reason = br.readVarString('ascii', 111);
 
   if (this.message === 'block' || this.message === 'tx')
-    this.data = p.readHash('hex');
+    this.data = br.readHash('hex');
   else
     this.data = null;
 
@@ -1728,14 +1728,14 @@ FilterAddPacket.prototype.type = exports.types.FILTERADD;
  */
 
 FilterAddPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeVarBytes(this.data);
+  bw.writeVarBytes(this.data);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -1745,8 +1745,8 @@ FilterAddPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 FilterAddPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.data = p.readVarBytes();
+  var br = BufferReader(data);
+  this.data = br.readVarBytes();
   return this;
 };
 
@@ -1899,19 +1899,19 @@ GetUTXOsPacket.prototype.type = exports.types.GETUTXOS;
  */
 
 GetUTXOsPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i;
 
-  p.writeU8(this.mempool ? 1 : 0);
-  p.writeVarint(this.prevout.length);
+  bw.writeU8(this.mempool ? 1 : 0);
+  bw.writeVarint(this.prevout.length);
 
   for (i = 0; i < this.prevout.length; i++)
-    this.prevout[i].toRaw(p);
+    this.prevout[i].toRaw(bw);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -1921,15 +1921,15 @@ GetUTXOsPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 GetUTXOsPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, count;
 
-  this.mempool = p.readU8() === 1;
+  this.mempool = br.readU8() === 1;
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.prevout.push(Outpoint.fromRaw(p));
+    this.prevout.push(Outpoint.fromRaw(br));
 
   return this;
 };
@@ -2025,7 +2025,7 @@ UTXOsPacket.fromOptions = function fromOptions(options) {
  */
 
 UTXOsPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var map = new Buffer((this.hits.length + 7) / 8 | 0);
   var i, bit, oct, coin, height;
 
@@ -2035,10 +2035,10 @@ UTXOsPacket.prototype.toRaw = function toRaw(writer) {
     map[oct] |= +this.hits[i] << (7 - bit);
   }
 
-  p.writeU32(this.height);
-  p.writeHash(this.tip);
-  p.writeVarBytes(map);
-  p.writeVarInt(this.coins.length);
+  bw.writeU32(this.height);
+  bw.writeHash(this.tip);
+  bw.writeVarBytes(map);
+  bw.writeVarInt(this.coins.length);
 
   for (i = 0; i < this.coins.length; i++) {
     coin = this.coins[i];
@@ -2047,16 +2047,16 @@ UTXOsPacket.prototype.toRaw = function toRaw(writer) {
     if (height === -1)
       height = 0x7fffffff;
 
-    p.writeU32(coin.version);
-    p.writeU32(height);
-    p.write64(coin.value);
-    p.writeVarBytes(coin.script.toRaw());
+    bw.writeU32(coin.version);
+    bw.writeU32(height);
+    bw.write64(coin.value);
+    bw.writeVarBytes(coin.script.toRaw());
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2066,15 +2066,15 @@ UTXOsPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 UTXOsPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, bit, oct, coin, output;
   var version, height, map, count;
 
-  this.height = p.readU32();
-  this.tip = p.readHash('hex');
+  this.height = br.readU32();
+  this.tip = br.readHash('hex');
 
-  map = p.readVarBytes();
-  count = p.readVarint();
+  map = br.readVarBytes();
+  count = br.readVarint();
 
   for (i = 0; i < map.length * 8; i++) {
     bit = i % 8;
@@ -2083,14 +2083,14 @@ UTXOsPacket.prototype.fromRaw = function fromRaw(data) {
   }
 
   for (i = 0; i < count; i++) {
-    version = p.readU32();
-    height = p.readU32();
+    version = br.readU32();
+    height = br.readU32();
     coin = new Coin();
 
     if (height === 0x7fffffff)
       height = -1;
 
-    output = Output.fromRaw(p);
+    output = Output.fromRaw(br);
 
     coin.version = version;
     coin.height = height;
@@ -2194,14 +2194,14 @@ FeeFilterPacket.prototype.type = exports.types.FEEFILTER;
  */
 
 FeeFilterPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.write64(this.rate);
+  bw.write64(this.rate);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2211,8 +2211,8 @@ FeeFilterPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 FeeFilterPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.rate = p.read64N();
+  var br = BufferReader(data);
+  this.rate = br.read64N();
   return this;
 };
 
@@ -2260,15 +2260,15 @@ SendCmpctPacket.prototype.type = exports.types.SENDCMPCT;
  */
 
 SendCmpctPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeU8(this.mode);
-  p.writeU64(this.version);
+  bw.writeU8(this.mode);
+  bw.writeU64(this.version);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2278,9 +2278,9 @@ SendCmpctPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 SendCmpctPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.mode = p.readU8();
-  this.version = p.readU53();
+  var br = BufferReader(data);
+  this.mode = br.readU8();
+  this.version = br.readU53();
   return this;
 };
 
@@ -2503,15 +2503,15 @@ EncinitPacket.prototype.type = exports.types.ENCINIT;
  */
 
 EncinitPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeBytes(this.publicKey);
-  p.writeU8(this.cipher);
+  bw.writeBytes(this.publicKey);
+  bw.writeU8(this.cipher);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2521,9 +2521,9 @@ EncinitPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 EncinitPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.publicKey = p.readBytes(33);
-  this.cipher = p.readU8();
+  var br = BufferReader(data);
+  this.publicKey = br.readBytes(33);
+  this.cipher = br.readU8();
   return this;
 };
 
@@ -2568,14 +2568,14 @@ EncackPacket.prototype.type = exports.types.ENCACK;
  */
 
 EncackPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeBytes(this.publicKey);
+  bw.writeBytes(this.publicKey);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2585,8 +2585,8 @@ EncackPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 EncackPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.publicKey = p.readBytes(33);
+  var br = BufferReader(data);
+  this.publicKey = br.readBytes(33);
   return this;
 };
 
@@ -2631,14 +2631,14 @@ AuthChallengePacket.prototype.type = exports.types.AUTHCHALLENGE;
  */
 
 AuthChallengePacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeBytes(this.hash);
+  bw.writeBytes(this.hash);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2648,8 +2648,8 @@ AuthChallengePacket.prototype.toRaw = function toRaw(writer) {
  */
 
 AuthChallengePacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.hash = p.readHash();
+  var br = BufferReader(data);
+  this.hash = br.readHash();
   return this;
 };
 
@@ -2694,14 +2694,14 @@ AuthReplyPacket.prototype.type = exports.types.AUTHREPLY;
  */
 
 AuthReplyPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeBytes(this.signature);
+  bw.writeBytes(this.signature);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2711,8 +2711,8 @@ AuthReplyPacket.prototype.toRaw = function toRaw(writer) {
  */
 
 AuthReplyPacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.signature = p.readBytes(64);
+  var br = BufferReader(data);
+  this.signature = br.readBytes(64);
   return this;
 };
 
@@ -2757,14 +2757,14 @@ AuthProposePacket.prototype.type = exports.types.AUTHPROPOSE;
  */
 
 AuthProposePacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeBytes(this.hash);
+  bw.writeBytes(this.hash);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2774,8 +2774,8 @@ AuthProposePacket.prototype.toRaw = function toRaw(writer) {
  */
 
 AuthProposePacket.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.hash = p.readHash();
+  var br = BufferReader(data);
+  this.hash = br.readHash();
   return this;
 };
 
@@ -2822,14 +2822,14 @@ UnknownPacket.prototype.type = exports.types.UNKNOWN;
  */
 
 UnknownPacket.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeBytes(this.data);
+  bw.writeBytes(this.data);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**

lib/primitives/abstractblock.js

@@ -166,19 +166,19 @@ AbstractBlock.prototype.hash = function hash(enc) {
  */
 
 AbstractBlock.prototype.abbr = function abbr(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeU32(this.version);
-  p.writeHash(this.prevBlock);
-  p.writeHash(this.merkleRoot);
-  p.writeU32(this.ts);
-  p.writeU32(this.bits);
-  p.writeU32(this.nonce);
+  bw.writeU32(this.version);
+  bw.writeHash(this.prevBlock);
+  bw.writeHash(this.merkleRoot);
+  bw.writeU32(this.ts);
+  bw.writeU32(this.bits);
+  bw.writeU32(this.nonce);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**

lib/primitives/address.js

@@ -107,7 +107,7 @@ Address.prototype.getType = function getType() {
  */
 
 Address.prototype.toRaw = function toRaw(network) {
-  var p = new BufferWriter();
+  var bw = new BufferWriter();
   var prefix;
 
   if (!network)
@@ -118,15 +118,15 @@ Address.prototype.toRaw = function toRaw(network) {
 
   assert(prefix !== -1, 'Not a valid address prefix.');
 
-  p.writeU8(prefix);
+  bw.writeU8(prefix);
   if (this.version !== -1) {
-    p.writeU8(this.version);
-    p.writeU8(0);
+    bw.writeU8(this.version);
+    bw.writeU8(0);
   }
-  p.writeBytes(this.hash);
-  p.writeChecksum();
+  bw.writeBytes(this.hash);
+  bw.writeChecksum();
 
-  return p.render();
+  return bw.render();
 };
 
 /**
@@ -176,12 +176,12 @@ Address.prototype.inspect = function inspect() {
  */
 
 Address.prototype.fromRaw = function fromRaw(data) {
-  var i, p, prefix, network, type, version, hash;
+  var i, br, prefix, network, type, version, hash;
 
   assert(Buffer.isBuffer(data));
 
-  p = new BufferReader(data, true);
-  prefix = p.readU8();
+  br = new BufferReader(data, true);
+  prefix = br.readU8();
 
   for (i = 0; i < networks.types.length; i++) {
     network = networks[networks.types[i]];
@@ -193,15 +193,15 @@ Address.prototype.fromRaw = function fromRaw(data) {
   assert(i < networks.types.length, 'Unknown address prefix.');
 
   if (data.length > 25) {
-    version = p.readU8();
-    assert(p.readU8() === 0, 'Address version padding is non-zero.');
+    version = br.readU8();
+    assert(br.readU8() === 0, 'Address version padding is non-zero.');
   } else {
     version = -1;
   }
 
-  hash = p.readBytes(p.left() - 4);
+  hash = br.readBytes(br.left() - 4);
 
-  p.verifyChecksum();
+  br.verifyChecksum();
 
   return this.fromHash(hash, type, version, network.type);
 };

lib/primitives/block.js

@@ -646,29 +646,29 @@ Block.fromJSON = function fromJSON(json) {
  */
 
 Block.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, tx, witnessSize;
 
-  p.start();
+  br.start();
 
-  this.version = p.readU32(); // Technically signed
-  this.prevBlock = p.readHash('hex');
-  this.merkleRoot = p.readHash('hex');
-  this.ts = p.readU32();
-  this.bits = p.readU32();
-  this.nonce = p.readU32();
-  this.totalTX = p.readVarint();
+  this.version = br.readU32(); // Technically signed
+  this.prevBlock = br.readHash('hex');
+  this.merkleRoot = br.readHash('hex');
+  this.ts = br.readU32();
+  this.bits = br.readU32();
+  this.nonce = br.readU32();
+  this.totalTX = br.readVarint();
 
   witnessSize = 0;
 
   for (i = 0; i < this.totalTX; i++) {
-    tx = TX.fromRaw(p);
+    tx = TX.fromRaw(br);
     witnessSize += tx._witnessSize;
     this.addTX(tx);
   }
 
   if (!this.mutable) {
-    this._raw = p.endData();
+    this._raw = br.endData();
     this._size = this._raw.length;
     this._witnessSize = witnessSize;
   }
@@ -710,34 +710,34 @@ Block.prototype.toMerkle = function toMerkle(filter) {
  */
 
 Block.prototype.frame = function frame(witness, writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var witnessSize = 0;
   var i, tx;
 
-  p.writeU32(this.version);
-  p.writeHash(this.prevBlock);
-  p.writeHash(this.merkleRoot);
-  p.writeU32(this.ts);
-  p.writeU32(this.bits);
-  p.writeU32(this.nonce);
-  p.writeVarint(this.txs.length);
+  bw.writeU32(this.version);
+  bw.writeHash(this.prevBlock);
+  bw.writeHash(this.merkleRoot);
+  bw.writeU32(this.ts);
+  bw.writeU32(this.bits);
+  bw.writeU32(this.nonce);
+  bw.writeVarint(this.txs.length);
 
   for (i = 0; i < this.txs.length; i++) {
     tx = this.txs[i];
     if (witness) {
-      tx.toRaw(p);
+      tx.toRaw(bw);
       witnessSize += tx._lastWitnessSize;
     } else {
-      tx.toNormal(p);
+      tx.toNormal(bw);
     }
   }
 
   this._lastWitnessSize = witnessSize;
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**

lib/primitives/coin.js

@@ -203,22 +203,22 @@ Coin.prototype.fromJSON = function fromJSON(json) {
  */
 
 Coin.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var height = this.height;
 
   if (height === -1)
     height = 0x7fffffff;
 
-  p.writeU32(this.version);
-  p.writeU32(height);
-  p.write64(this.value);
-  p.writeVarBytes(this.script.toRaw());
-  p.writeU8(this.coinbase ? 1 : 0);
+  bw.writeU32(this.version);
+  bw.writeU32(height);
+  bw.write64(this.value);
+  bw.writeVarBytes(this.script.toRaw());
+  bw.writeU8(this.coinbase ? 1 : 0);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -228,13 +228,13 @@ Coin.prototype.toRaw = function toRaw(writer) {
  */
 
 Coin.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
 
-  this.version = p.readU32();
-  this.height = p.readU32();
-  this.value = p.read64N();
-  this.script.fromRaw(p.readVarBytes());
-  this.coinbase = p.readU8() === 1;
+  this.version = br.readU32();
+  this.height = br.readU32();
+  this.value = br.read64N();
+  this.script.fromRaw(br.readVarBytes());
+  this.coinbase = br.readU8() === 1;
 
   if (this.height === 0x7fffffff)
     this.height = -1;
@@ -262,7 +262,7 @@ Coin.fromRaw = function fromRaw(data, enc) {
  */
 
 Coin.prototype.toCompressed = function toCompressed(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var height = this.height;
   var bits;
 
@@ -277,15 +277,15 @@ Coin.prototype.toCompressed = function toCompressed(writer) {
   if (bits < 0)
     bits += 0x100000000;
 
-  p.writeVarint(this.version);
-  p.writeU32(bits);
-  p.writeVarint(this.value);
-  compress.script(this.script, p);
+  bw.writeVarint(this.version);
+  bw.writeU32(bits);
+  bw.writeVarint(this.value);
+  compress.script(this.script, bw);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -295,15 +295,15 @@ Coin.prototype.toCompressed = function toCompressed(writer) {
  */
 
 Coin.prototype.fromCompressed = function fromCompressed(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var bits;
 
-  this.version = p.readVarint();
-  bits = p.readU32();
+  this.version = br.readVarint();
+  bits = br.readU32();
   this.height = bits >>> 1;
   this.coinbase = (bits & 1) !== 0;
-  this.value = p.readVarint();
-  decompress.script(p, this.script);
+  this.value = br.readVarint();
+  decompress.script(br, this.script);
 
   if (this.height === 0x7fffffff)
     this.height = -1;

lib/primitives/headers.js

@@ -81,20 +81,20 @@ Headers.prototype.inspect = function inspect() {
  */
 
 Headers.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeU32(this.version);
-  p.writeHash(this.prevBlock);
-  p.writeHash(this.merkleRoot);
-  p.writeU32(this.ts);
-  p.writeU32(this.bits);
-  p.writeU32(this.nonce);
-  p.writeVarint(this.totalTX);
+  bw.writeU32(this.version);
+  bw.writeHash(this.prevBlock);
+  bw.writeHash(this.merkleRoot);
+  bw.writeU32(this.ts);
+  bw.writeU32(this.bits);
+  bw.writeU32(this.nonce);
+  bw.writeVarint(this.totalTX);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -104,15 +104,15 @@ Headers.prototype.toRaw = function toRaw(writer) {
  */
 
 Headers.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
 
-  this.version = p.readU32(); // Technically signed
-  this.prevBlock = p.readHash('hex');
-  this.merkleRoot = p.readHash('hex');
-  this.ts = p.readU32();
-  this.bits = p.readU32();
-  this.nonce = p.readU32();
-  this.totalTX = p.readVarint();
+  this.version = br.readU32(); // Technically signed
+  this.prevBlock = br.readHash('hex');
+  this.merkleRoot = br.readHash('hex');
+  this.ts = br.readU32();
+  this.bits = br.readU32();
+  this.nonce = br.readU32();
+  this.totalTX = br.readVarint();
 
   return this;
 };
@@ -137,14 +137,14 @@ Headers.fromRaw = function fromRaw(data, enc) {
  */
 
 Headers.prototype.fromAbbr = function fromAbbr(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
 
-  this.version = p.readU32(); // Technically signed
-  this.prevBlock = p.readHash('hex');
-  this.merkleRoot = p.readHash('hex');
-  this.ts = p.readU32();
-  this.bits = p.readU32();
-  this.nonce = p.readU32();
+  this.version = br.readU32(); // Technically signed
+  this.prevBlock = br.readHash('hex');
+  this.merkleRoot = br.readHash('hex');
+  this.ts = br.readU32();
+  this.bits = br.readU32();
+  this.nonce = br.readU32();
 
   return this;
 };

lib/primitives/input.js

@@ -317,16 +317,16 @@ Input.fromJSON = function fromJSON(json) {
  */
 
 Input.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  this.prevout.toRaw(p);
-  p.writeVarBytes(this.script.toRaw());
-  p.writeU32(this.sequence);
+  this.prevout.toRaw(bw);
+  bw.writeVarBytes(this.script.toRaw());
+  bw.writeU32(this.sequence);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -335,11 +335,11 @@ Input.prototype.toRaw = function toRaw(writer) {
  */
 
 Input.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
 
-  this.prevout.fromRaw(p);
-  this.script.fromRaw(p.readVarBytes());
-  this.sequence = p.readU32();
+  this.prevout.fromRaw(br);
+  this.script.fromRaw(br.readVarBytes());
+  this.sequence = br.readU32();
 
   return this;
 };
@@ -365,15 +365,15 @@ Input.fromRaw = function fromRaw(data, enc) {
  */
 
 Input.prototype.toExtended = function toExtended(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  this.toRaw(p);
-  this.witness.toRaw(p);
+  this.toRaw(bw);
+  this.witness.toRaw(bw);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -383,9 +383,9 @@ Input.prototype.toExtended = function toExtended(writer) {
  */
 
 Input.prototype.fromExtended = function fromExtended(data) {
-  var p = BufferReader(data);
-  this.fromRaw(p);
-  this.witness.fromRaw(p);
+  var br = BufferReader(data);
+  this.fromRaw(br);
+  this.witness.fromRaw(br);
   return this;
 };
 

lib/primitives/invitem.js

@@ -33,15 +33,15 @@ function InvItem(type, hash) {
  */
 
 InvItem.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeU32(this.type);
-  p.writeHash(this.hash);
+  bw.writeU32(this.type);
+  bw.writeHash(this.hash);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -50,9 +50,9 @@ InvItem.prototype.toRaw = function toRaw(writer) {
  */
 
 InvItem.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.type = p.readU32();
-  this.hash = p.readHash('hex');
+  var br = BufferReader(data);
+  this.type = br.readU32();
+  this.hash = br.readHash('hex');
   return this;
 };
 

lib/primitives/keyring.js

@@ -270,19 +270,19 @@ KeyRing.fromScript = function fromScript(key, script, compressed, network) {
  */
 
 KeyRing.prototype.toSecret = function toSecret() {
-  var p = new BufferWriter();
+  var bw = new BufferWriter();
 
   assert(this.privateKey, 'Cannot serialize without private key.');
 
-  p.writeU8(this.network.keyPrefix.privkey);
-  p.writeBytes(this.privateKey);
+  bw.writeU8(this.network.keyPrefix.privkey);
+  bw.writeBytes(this.privateKey);
 
   if (this.publicKey.length === 33)
-    p.writeU8(1);
+    bw.writeU8(1);
 
-  p.writeChecksum();
+  bw.writeChecksum();
 
-  return base58.encode(p.render());
+  return base58.encode(bw.render());
 };
 
 /**
@@ -292,10 +292,10 @@ KeyRing.prototype.toSecret = function toSecret() {
  */
 
 KeyRing.prototype.fromSecret = function fromSecret(data) {
-  var p = new BufferReader(base58.decode(data), true);
+  var br = new BufferReader(base58.decode(data), true);
   var i, prefix, version, type, key, compressed;
 
-  version = p.readU8();
+  version = br.readU8();
 
   for (i = 0; i < networks.types.length; i++) {
     type = networks.types[i];
@@ -306,16 +306,16 @@ KeyRing.prototype.fromSecret = function fromSecret(data) {
 
   assert(i < networks.types.length, 'Network not found.');
 
-  key = p.readBytes(32);
+  key = br.readBytes(32);
 
-  if (p.left() > 4) {
-    assert(p.readU8() === 1, 'Bad compression flag.');
+  if (br.left() > 4) {
+    assert(br.readU8() === 1, 'Bad compression flag.');
     compressed = true;
   } else {
     compressed = false;
   }
 
-  p.verifyChecksum();
+  br.verifyChecksum();
 
   return this.fromPrivate(key, compressed, type);
 };
@@ -870,7 +870,7 @@ KeyRing.fromJSON = function fromJSON(json) {
  */
 
 KeyRing.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
   var field = 0;
 
   if (this.witness)
@@ -879,24 +879,24 @@ KeyRing.prototype.toRaw = function toRaw(writer) {
   if (this.nested)
     field |= 2;
 
-  p.writeU8(field);
+  bw.writeU8(field);
 
   if (this.privateKey) {
-    p.writeVarBytes(this.privateKey);
-    p.writeU8(this.publicKey.length === 33);
+    bw.writeVarBytes(this.privateKey);
+    bw.writeU8(this.publicKey.length === 33);
   } else {
-    p.writeVarBytes(this.publicKey);
+    bw.writeVarBytes(this.publicKey);
   }
 
   if (this.script)
-    p.writeVarBytes(this.script.toRaw());
+    bw.writeVarBytes(this.script.toRaw());
   else
-    p.writeVarint(0);
+    bw.writeVarint(0);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -906,20 +906,20 @@ KeyRing.prototype.toRaw = function toRaw(writer) {
  */
 
 KeyRing.prototype.fromRaw = function fromRaw(data, network) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
   var field, compressed, key, script;
 
   this.network = Network.get(network);
 
-  field = p.readU8();
+  field = br.readU8();
 
   this.witness = (field & 1) !== 0;
   this.nested = (field & 2) !== 0;
 
-  key = p.readVarBytes();
+  key = br.readVarBytes();
 
   if (key.length === 32) {
-    compressed = p.readU8() === 1;
+    compressed = br.readU8() === 1;
     this.privateKey = key;
     this.publicKey = ec.publicKeyCreate(key, compressed);
   } else {
@@ -927,7 +927,7 @@ KeyRing.prototype.fromRaw = function fromRaw(data, network) {
     assert(ec.publicKeyVerify(key), 'Invalid public key.');
   }
 
-  script = p.readVarBytes();
+  script = br.readVarBytes();
 
   if (script.length > 0)
     this.script = Script.fromRaw(script);

lib/primitives/memblock.js

@@ -132,36 +132,36 @@ MemBlock.prototype.getCoinbaseHeight = function getCoinbaseHeight() {
  */
 
 MemBlock.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data, true);
+  var br = BufferReader(data, true);
   var height = -1;
   var inCount, input;
 
-  this.version = p.readU32(); // Technically signed
-  this.prevBlock = p.readHash('hex');
-  this.merkleRoot = p.readHash('hex');
-  this.ts = p.readU32();
-  this.bits = p.readU32();
-  this.nonce = p.readU32();
-  this.totalTX = p.readVarint();
+  this.version = br.readU32(); // Technically signed
+  this.prevBlock = br.readHash('hex');
+  this.merkleRoot = br.readHash('hex');
+  this.ts = br.readU32();
+  this.bits = br.readU32();
+  this.nonce = br.readU32();
+  this.totalTX = br.readVarint();
 
   if (this.version > 1 && this.totalTX > 0) {
-    p.seek(4);
-    inCount = p.readVarint();
+    br.seek(4);
+    inCount = br.readVarint();
 
     if (inCount === 0) {
-      if (p.readU8() !== 0)
-        inCount = p.readVarint();
+      if (br.readU8() !== 0)
+        inCount = br.readVarint();
     }
 
     if (inCount > 0) {
-      p.seek(36);
-      input = p.readVarBytes();
+      br.seek(36);
+      input = br.readVarBytes();
       height = Script.getCoinbaseHeight(input);
     }
   }
 
   this.coinbaseHeight = height;
-  this.raw = p.data;
+  this.raw = br.data;
 
   return this;
 };

lib/primitives/merkleblock.js

@@ -344,28 +344,28 @@ MerkleBlock.prototype.inspect = function inspect() {
  */
 
 MerkleBlock.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i;
 
-  p.writeU32(this.version);
-  p.writeHash(this.prevBlock);
-  p.writeHash(this.merkleRoot);
-  p.writeU32(this.ts);
-  p.writeU32(this.bits);
-  p.writeU32(this.nonce);
-  p.writeU32(this.totalTX);
+  bw.writeU32(this.version);
+  bw.writeHash(this.prevBlock);
+  bw.writeHash(this.merkleRoot);
+  bw.writeU32(this.ts);
+  bw.writeU32(this.bits);
+  bw.writeU32(this.nonce);
+  bw.writeU32(this.totalTX);
 
-  p.writeVarint(this.hashes.length);
+  bw.writeVarint(this.hashes.length);
 
   for (i = 0; i < this.hashes.length; i++)
-    p.writeHash(this.hashes[i]);
+    bw.writeHash(this.hashes[i]);
 
-  p.writeVarBytes(this.flags);
+  bw.writeVarBytes(this.flags);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -375,23 +375,23 @@ MerkleBlock.prototype.toRaw = function toRaw(writer) {
  */
 
 MerkleBlock.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, count;
 
-  this.version = p.readU32();
-  this.prevBlock = p.readHash('hex');
-  this.merkleRoot = p.readHash('hex');
-  this.ts = p.readU32();
-  this.bits = p.readU32();
-  this.nonce = p.readU32();
-  this.totalTX = p.readU32();
+  this.version = br.readU32();
+  this.prevBlock = br.readHash('hex');
+  this.merkleRoot = br.readHash('hex');
+  this.ts = br.readU32();
+  this.bits = br.readU32();
+  this.nonce = br.readU32();
+  this.totalTX = br.readU32();
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.hashes.push(p.readHash());
+    this.hashes.push(br.readHash());
 
-  this.flags = p.readVarBytes();
+  this.flags = br.readVarBytes();
 
   return this;
 };

lib/primitives/netaddress.js

@@ -253,14 +253,14 @@ NetworkAddress.fromSocket = function fromSocket(hostname) {
  */
 
 NetworkAddress.prototype.fromRaw = function fromRaw(data, full) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var now = time.now();
 
   // only version >= 31402
-  this.ts = full ? p.readU32() : 0;
-  this.services = p.readU53();
-  this.host = IP.toString(p.readBytes(16));
-  this.port = p.readU16BE();
+  this.ts = full ? br.readU32() : 0;
+  this.services = br.readU53();
+  this.host = IP.toString(br.readBytes(16));
+  this.port = br.readU16BE();
 
   if (this.ts <= 100000000 || this.ts > now + 10 * 60)
     this.ts = now - 5 * 24 * 60 * 60;
@@ -288,19 +288,19 @@ NetworkAddress.fromRaw = function fromRaw(data, full) {
  */
 
 NetworkAddress.prototype.toRaw = function toRaw(full, writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
   if (full)
-    p.writeU32(this.ts);
+    bw.writeU32(this.ts);
 
-  p.writeU64(this.services);
-  p.writeBytes(IP.toBuffer(this.host));
-  p.writeU16BE(this.port);
+  bw.writeU64(this.services);
+  bw.writeBytes(IP.toBuffer(this.host));
+  bw.writeU16BE(this.port);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /*

lib/primitives/outpoint.js

@@ -70,15 +70,15 @@ Outpoint.prototype.isNull = function isNull() {
  */
 
 Outpoint.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeHash(this.hash);
-  p.writeU32(this.index);
+  bw.writeHash(this.hash);
+  bw.writeU32(this.index);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -88,9 +88,9 @@ Outpoint.prototype.toRaw = function toRaw(writer) {
  */
 
 Outpoint.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.hash = p.readHash('hex');
-  this.index = p.readU32();
+  var br = BufferReader(data);
+  this.hash = br.readHash('hex');
+  this.index = br.readU32();
   return this;
 };
 

lib/primitives/output.js

@@ -224,15 +224,15 @@ Output.fromJSON = function fromJSON(json) {
  */
 
 Output.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.write64(this.value);
-  p.writeVarBytes(this.script.toRaw());
+  bw.write64(this.value);
+  bw.writeVarBytes(this.script.toRaw());
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -242,10 +242,10 @@ Output.prototype.toRaw = function toRaw(writer) {
  */
 
 Output.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
 
-  this.value = p.read64N();
-  this.script.fromRaw(p.readVarBytes());
+  this.value = br.read64N();
+  this.script.fromRaw(br.readVarBytes());
 
   return this;
 };

lib/primitives/tx.js

@@ -483,7 +483,7 @@ TX.prototype.signatureHash = function signatureHash(index, prev, type, version)
 
 TX.prototype.signatureHashV0 = function signatureHashV0(index, prev, type) {
   var i, input, output;
-  var p = new BufferWriter();
+  var bw = new BufferWriter();
   var hashType = type & 0x1f;
 
   if (hashType === constants.hashType.SINGLE) {
@@ -496,60 +496,60 @@ TX.prototype.signatureHashV0 = function signatureHashV0(index, prev, type) {
   // Remove all code separators.
   prev = prev.removeSeparators();
 
-  p.writeU32(this.version);
+  bw.writeU32(this.version);
 
   if (type & constants.hashType.ANYONECANPAY) {
-    p.writeVarint(1);
+    bw.writeVarint(1);
 
     // Serialize only the current
     // input if ANYONECANPAY.
     input = this.inputs[index];
 
     // Outpoint.
-    p.writeHash(input.prevout.hash);
-    p.writeU32(input.prevout.index);
+    bw.writeHash(input.prevout.hash);
+    bw.writeU32(input.prevout.index);
 
     // Replace script with previous
     // output script if current index.
-    p.writeVarBytes(prev.toRaw());
-    p.writeU32(input.sequence);
+    bw.writeVarBytes(prev.toRaw());
+    bw.writeU32(input.sequence);
   } else {
-    p.writeVarint(this.inputs.length);
+    bw.writeVarint(this.inputs.length);
     for (i = 0; i < this.inputs.length; i++) {
       input = this.inputs[i];
 
       // Outpoint.
-      p.writeHash(input.prevout.hash);
-      p.writeU32(input.prevout.index);
+      bw.writeHash(input.prevout.hash);
+      bw.writeU32(input.prevout.index);
 
       // Replace script with previous
       // output script if current index.
       if (i === index) {
-        p.writeVarBytes(prev.toRaw());
-        p.writeU32(input.sequence);
+        bw.writeVarBytes(prev.toRaw());
+        bw.writeU32(input.sequence);
         continue;
       }
 
       // Script is null.
-      p.writeVarint(0);
+      bw.writeVarint(0);
 
       // Sequences are 0 if NONE or SINGLE.
       if (hashType === constants.hashType.NONE
           || hashType === constants.hashType.SINGLE) {
-        p.writeU32(0);
+        bw.writeU32(0);
       } else {
-        p.writeU32(input.sequence);
+        bw.writeU32(input.sequence);
       }
     }
   }
 
   if (hashType === constants.hashType.NONE) {
     // No outputs if NONE.
-    p.writeVarint(0);
+    bw.writeVarint(0);
   } else if (hashType === constants.hashType.SINGLE) {
     // Drop all outputs after the
     // current input index if SINGLE.
-    p.writeVarint(index + 1);
+    bw.writeVarint(index + 1);
 
     for (i = 0; i < index + 1; i++) {
       output = this.outputs[i];
@@ -557,33 +557,33 @@ TX.prototype.signatureHashV0 = function signatureHashV0(index, prev, type) {
       // Regular serialization if
       // at current input index.
       if (i === index) {
-        p.write64(output.value);
-        p.writeVarBytes(output.script.toRaw());
+        bw.write64(output.value);
+        bw.writeVarBytes(output.script.toRaw());
         continue;
       }
 
       // Null all outputs not at
       // current input index.
-      p.write64(-1);
-      p.writeVarint(0);
+      bw.write64(-1);
+      bw.writeVarint(0);
     }
   } else {
     // Regular output serialization if ALL.
-    p.writeVarint(this.outputs.length);
+    bw.writeVarint(this.outputs.length);
 
     for (i = 0; i < this.outputs.length; i++) {
       output = this.outputs[i];
-      p.write64(output.value);
-      p.writeVarBytes(output.script.toRaw());
+      bw.write64(output.value);
+      bw.writeVarBytes(output.script.toRaw());
     }
   }
 
-  p.writeU32(this.locktime);
+  bw.writeU32(this.locktime);
 
   // Append the hash type.
-  p.writeU32(type);
+  bw.writeU32(type);
 
-  return crypto.hash256(p.render());
+  return crypto.hash256(bw.render());
 };
 
 /**
@@ -596,20 +596,20 @@ TX.prototype.signatureHashV0 = function signatureHashV0(index, prev, type) {
  */
 
 TX.prototype.signatureHashV1 = function signatureHashV1(index, prev, type) {
-  var i, p, input, output, prevouts, sequences, outputs;
+  var i, bw, input, output, prevouts, sequences, outputs;
 
   if (!(type & constants.hashType.ANYONECANPAY)) {
     if (this._hashPrevouts) {
       prevouts = this._hashPrevouts;
     } else {
-      p = new BufferWriter();
+      bw = new BufferWriter();
 
       for (i = 0; i < this.inputs.length; i++) {
         input = this.inputs[i];
-        input.prevout.toRaw(p);
+        input.prevout.toRaw(bw);
       }
 
-      prevouts = crypto.hash256(p.render());
+      prevouts = crypto.hash256(bw.render());
 
       if (!this.mutable)
         this._hashPrevouts = prevouts;
@@ -624,14 +624,14 @@ TX.prototype.signatureHashV1 = function signatureHashV1(index, prev, type) {
     if (this._hashSequence) {
       sequences = this._hashSequence;
     } else {
-      p = new BufferWriter();
+      bw = new BufferWriter();
 
       for (i = 0; i < this.inputs.length; i++) {
         input = this.inputs[i];
-        p.writeU32(input.sequence);
+        bw.writeU32(input.sequence);
       }
 
-      sequences = crypto.hash256(p.render());
+      sequences = crypto.hash256(bw.render());
 
       if (!this.mutable)
         this._hashSequence = sequences;
@@ -645,14 +645,14 @@ TX.prototype.signatureHashV1 = function signatureHashV1(index, prev, type) {
     if (this._hashOutputs) {
       outputs = this._hashOutputs;
     } else {
-      p = new BufferWriter();
+      bw = new BufferWriter();
 
       for (i = 0; i < this.outputs.length; i++) {
         output = this.outputs[i];
-        output.toRaw(p);
+        output.toRaw(bw);
       }
 
-      outputs = crypto.hash256(p.render());
+      outputs = crypto.hash256(bw.render());
 
       if (!this.mutable)
         this._hashOutputs = outputs;
@@ -666,21 +666,21 @@ TX.prototype.signatureHashV1 = function signatureHashV1(index, prev, type) {
 
   input = this.inputs[index];
 
-  p = new BufferWriter();
+  bw = new BufferWriter();
 
-  p.writeU32(this.version);
-  p.writeBytes(prevouts);
-  p.writeBytes(sequences);
-  p.writeHash(input.prevout.hash);
-  p.writeU32(input.prevout.index);
-  p.writeVarBytes(prev.toRaw());
-  p.write64(input.coin.value);
-  p.writeU32(input.sequence);
-  p.writeBytes(outputs);
-  p.writeU32(this.locktime);
-  p.writeU32(type);
+  bw.writeU32(this.version);
+  bw.writeBytes(prevouts);
+  bw.writeBytes(sequences);
+  bw.writeHash(input.prevout.hash);
+  bw.writeU32(input.prevout.index);
+  bw.writeVarBytes(prev.toRaw());
+  bw.write64(input.coin.value);
+  bw.writeU32(input.sequence);
+  bw.writeBytes(outputs);
+  bw.writeU32(this.locktime);
+  bw.writeU32(type);
 
-  return crypto.hash256(p.render());
+  return crypto.hash256(bw.render());
 };
 
 /**
@@ -2177,34 +2177,34 @@ TX.fromRaw = function fromRaw(data, enc) {
  */
 
 TX.prototype.fromRaw = function fromRaw(data) {
-  var p, i, count;
+  var br, i, count;
 
   if (TX.isWitness(data))
     return this.fromWitness(data);
 
-  p = BufferReader(data);
-  p.start();
+  br = BufferReader(data);
+  br.start();
 
-  this.version = p.readU32(); // Technically signed
+  this.version = br.readU32(); // Technically signed
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.inputs.push(Input.fromRaw(p));
+    this.inputs.push(Input.fromRaw(br));
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.outputs.push(Output.fromRaw(p));
+    this.outputs.push(Output.fromRaw(br));
 
-  this.locktime = p.readU32();
+  this.locktime = br.readU32();
 
   if (!this.mutable) {
-    this._raw = p.endData();
+    this._raw = br.endData();
     this._size = this._raw.length;
     this._witnessSize = 0;
   } else {
-    p.end();
+    br.end();
   }
 
   return this;
@@ -2218,47 +2218,47 @@ TX.prototype.fromRaw = function fromRaw(data) {
  */
 
 TX.prototype.fromWitness = function fromWitness(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var flag = 0;
   var witnessSize = 0;
   var hasWitness = false;
   var i, count, input;
 
-  p.start();
+  br.start();
 
-  this.version = p.readU32(); // Technically signed
+  this.version = br.readU32(); // Technically signed
 
-  assert(p.readU8() === 0, 'Non-zero marker.');
+  assert(br.readU8() === 0, 'Non-zero marker.');
 
-  flag = p.readU8();
+  flag = br.readU8();
 
   assert(flag !== 0, 'Flag byte is zero.');
 
   this.flag = flag;
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.inputs.push(Input.fromRaw(p));
+    this.inputs.push(Input.fromRaw(br));
 
-  count = p.readVarint();
+  count = br.readVarint();
 
   for (i = 0; i < count; i++)
-    this.outputs.push(Output.fromRaw(p));
+    this.outputs.push(Output.fromRaw(br));
 
   if (flag & 1) {
     flag ^= 1;
 
-    p.start();
+    br.start();
 
     for (i = 0; i < this.inputs.length; i++) {
       input = this.inputs[i];
-      input.witness.fromRaw(p);
+      input.witness.fromRaw(br);
       if (input.witness.items.length > 0)
         hasWitness = true;
     }
 
-    witnessSize = p.end() + 2;
+    witnessSize = br.end() + 2;
   }
 
   if (flag !== 0)
@@ -2270,14 +2270,14 @@ TX.prototype.fromWitness = function fromWitness(data) {
   if (this.inputs.length === 0 && this.outputs.length !== 0)
     throw new Error('Zero input witness tx.');
 
-  this.locktime = p.readU32();
+  this.locktime = br.readU32();
 
   if (!this.mutable && hasWitness) {
-    this._raw = p.endData();
+    this._raw = br.endData();
     this._size = this._raw.length;
     this._witnessSize = witnessSize;
   } else {
-    p.end();
+    br.end();
   }
 
   return this;
@@ -2291,32 +2291,32 @@ TX.prototype.fromWitness = function fromWitness(data) {
  */
 
 TX.prototype.frameNormal = function frameNormal(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i;
 
   if (this.inputs.length === 0 && this.outputs.length !== 0)
     throw new Error('Cannot serialize zero-input tx.');
 
-  p.writeU32(this.version);
+  bw.writeU32(this.version);
 
-  p.writeVarint(this.inputs.length);
+  bw.writeVarint(this.inputs.length);
 
   for (i = 0; i < this.inputs.length; i++)
-    this.inputs[i].toRaw(p);
+    this.inputs[i].toRaw(bw);
 
-  p.writeVarint(this.outputs.length);
+  bw.writeVarint(this.outputs.length);
 
   for (i = 0; i < this.outputs.length; i++)
-    this.outputs[i].toRaw(p);
+    this.outputs[i].toRaw(bw);
 
-  p.writeU32(this.locktime);
+  bw.writeU32(this.locktime);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
   this._lastWitnessSize = 0;
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2328,35 +2328,35 @@ TX.prototype.frameNormal = function frameNormal(writer) {
  */
 
 TX.prototype.frameWitness = function frameWitness(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var witnessSize = 0;
   var i, start;
 
   if (this.inputs.length === 0 && this.outputs.length !== 0)
     throw new Error('Cannot serialize zero-input tx.');
 
-  p.writeU32(this.version);
-  p.writeU8(0);
-  p.writeU8(this.flag);
+  bw.writeU32(this.version);
+  bw.writeU8(0);
+  bw.writeU8(this.flag);
 
-  p.writeVarint(this.inputs.length);
+  bw.writeVarint(this.inputs.length);
 
   for (i = 0; i < this.inputs.length; i++)
-    this.inputs[i].toRaw(p);
+    this.inputs[i].toRaw(bw);
 
-  p.writeVarint(this.outputs.length);
+  bw.writeVarint(this.outputs.length);
 
   for (i = 0; i < this.outputs.length; i++)
-    this.outputs[i].toRaw(p);
+    this.outputs[i].toRaw(bw);
 
-  start = p.written;
+  start = bw.written;
 
   for (i = 0; i < this.inputs.length; i++)
-    this.inputs[i].witness.toRaw(p);
+    this.inputs[i].witness.toRaw(bw);
 
-  witnessSize += p.written - start;
+  witnessSize += bw.written - start;
 
-  p.writeU32(this.locktime);
+  bw.writeU32(this.locktime);
 
   if (witnessSize === this.inputs.length)
     throw new Error('Cannot serialize empty-witness tx.');
@@ -2364,9 +2364,9 @@ TX.prototype.frameWitness = function frameWitness(writer) {
   this._lastWitnessSize = witnessSize + 2;
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2402,20 +2402,20 @@ TX.isWitness = function isWitness(data) {
  */
 
 TX.prototype.toExtended = function toExtended(saveCoins, writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var height = this.height;
   var index = this.index;
   var i, input, field, bit, oct;
 
-  this.toRaw(p);
+  this.toRaw(bw);
 
-  p.writeU32(this.ps);
+  bw.writeU32(this.ps);
 
   if (this.block) {
-    p.writeU8(1);
-    p.writeHash(this.block);
+    bw.writeU8(1);
+    bw.writeHash(this.block);
   } else {
-    p.writeU8(0);
+    bw.writeU8(0);
   }
 
   if (height === -1)
@@ -2424,15 +2424,15 @@ TX.prototype.toExtended = function toExtended(saveCoins, writer) {
   if (index === -1)
     index = 0x7fffffff;
 
-  p.writeU32(height);
-  p.writeU32(this.ts);
-  p.writeU32(index);
+  bw.writeU32(height);
+  bw.writeU32(this.ts);
+  bw.writeU32(index);
 
   if (saveCoins) {
     field = new Buffer(Math.ceil(this.inputs.length / 8));
     field.fill(0);
 
-    p.writeBytes(field);
+    bw.writeBytes(field);
 
     for (i = 0; i < this.inputs.length; i++) {
       input = this.inputs[i];
@@ -2444,14 +2444,14 @@ TX.prototype.toExtended = function toExtended(saveCoins, writer) {
         continue;
       }
 
-      input.coin.toRaw(p);
+      input.coin.toRaw(bw);
     }
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2462,19 +2462,19 @@ TX.prototype.toExtended = function toExtended(saveCoins, writer) {
  */
 
 TX.prototype.fromExtended = function fromExtended(data, saveCoins) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, input, coin, field, bit, oct, spent;
 
-  this.fromRaw(p);
+  this.fromRaw(br);
 
-  this.ps = p.readU32();
+  this.ps = br.readU32();
 
-  if (p.readU8() === 1)
-    this.block = p.readHash('hex');
+  if (br.readU8() === 1)
+    this.block = br.readHash('hex');
 
-  this.height = p.readU32();
-  this.ts = p.readU32();
-  this.index = p.readU32();
+  this.height = br.readU32();
+  this.ts = br.readU32();
+  this.index = br.readU32();
 
   if (this.height === 0x7fffffff)
     this.height = -1;
@@ -2483,7 +2483,7 @@ TX.prototype.fromExtended = function fromExtended(data, saveCoins) {
     this.index = -1;
 
   if (saveCoins) {
-    field = p.readBytes(Math.ceil(this.inputs.length / 8), true);
+    field = br.readBytes(Math.ceil(this.inputs.length / 8), true);
 
     for (i = 0; i < this.inputs.length; i++) {
       input = this.inputs[i];
@@ -2495,7 +2495,7 @@ TX.prototype.fromExtended = function fromExtended(data, saveCoins) {
       if (spent)
         continue;
 
-      coin = Coin.fromRaw(p);
+      coin = Coin.fromRaw(br);
       coin.hash = input.prevout.hash;
       coin.index = input.prevout.index;
 

lib/script/opcode.js

@@ -40,35 +40,35 @@ function Opcode(value, data) {
  */
 
 Opcode.prototype.toRaw = function toRaw() {
-  var p = new BufferWriter();
+  var bw = new BufferWriter();
 
   if (this.value === -1)
     throw new Error('Cannot reserialize a parse error.');
 
   if (this.data) {
     if (this.value <= 0x4b) {
-      p.writeU8(this.data.length);
-      p.writeBytes(this.data);
+      bw.writeU8(this.data.length);
+      bw.writeBytes(this.data);
     } else if (this.value === opcodes.OP_PUSHDATA1) {
-      p.writeU8(opcodes.OP_PUSHDATA1);
-      p.writeU8(this.data.length);
-      p.writeBytes(this.data);
+      bw.writeU8(opcodes.OP_PUSHDATA1);
+      bw.writeU8(this.data.length);
+      bw.writeBytes(this.data);
     } else if (this.value === opcodes.OP_PUSHDATA2) {
-      p.writeU8(opcodes.OP_PUSHDATA2);
-      p.writeU16(this.data.length);
-      p.writeBytes(this.data);
+      bw.writeU8(opcodes.OP_PUSHDATA2);
+      bw.writeU16(this.data.length);
+      bw.writeBytes(this.data);
     } else if (this.value === opcodes.OP_PUSHDATA4) {
-      p.writeU8(opcodes.OP_PUSHDATA4);
-      p.writeU32(this.data.length);
-      p.writeBytes(this.data);
+      bw.writeU8(opcodes.OP_PUSHDATA4);
+      bw.writeU32(this.data.length);
+      bw.writeBytes(this.data);
     } else {
       throw new Error('Unknown pushdata opcode.');
     }
   } else {
-    p.writeU8(this.value);
+    bw.writeU8(this.value);
   }
 
-  return p.render();
+  return bw.render();
 };
 
 /**

lib/script/script.js

@@ -1734,12 +1734,13 @@ Script.fromAddress = function fromAddress(address) {
  */
 
 Script.prototype.fromCommitment = function fromCommitment(hash, flags) {
-  var p = new BufferWriter();
-  p.writeU32BE(0xaa21a9ed);
-  p.writeHash(hash);
+  var bw = new BufferWriter();
+
+  bw.writeU32BE(0xaa21a9ed);
+  bw.writeHash(hash);
 
   this.push(opcodes.OP_RETURN);
-  this.push(p.render());
+  this.push(bw.render());
 
   if (flags)
     this.push(flags);
@@ -2977,7 +2978,7 @@ Script.getWitnessSigops = function getWitnessSigops(input, output, witness, flag
  */
 
 Script.prototype.fromString = function fromString(code) {
-  var i, op, symbol, p;
+  var i, op, symbol, bw;
 
   assert(typeof code === 'string');
 
@@ -2988,7 +2989,7 @@ Script.prototype.fromString = function fromString(code) {
 
   code = code.split(/\s+/);
 
-  p = new BufferWriter();
+  bw = new BufferWriter();
 
   for (i = 0; i < code.length; i++) {
     op = code[i];
@@ -3002,27 +3003,27 @@ Script.prototype.fromString = function fromString(code) {
         assert(op[op.length - 1] === '\'', 'Unknown opcode.');
         op = op.slice(1, -1);
         op = Opcode.fromString(op);
-        p.writeBytes(op.toRaw());
+        bw.writeBytes(op.toRaw());
         continue;
       }
       if (/^-?\d+$/.test(op)) {
         op = new BN(op, 10);
         op = Opcode.fromNumber(op);
-        p.writeBytes(op.toRaw());
+        bw.writeBytes(op.toRaw());
         continue;
       }
       assert(op.indexOf('0x') === 0, 'Unknown opcode.');
       op = op.substring(2);
       assert(util.isHex(op), 'Unknown opcode.');
       op = new Buffer(op, 'hex');
-      p.writeBytes(op);
+      bw.writeBytes(op);
       continue;
     }
 
-    p.writeU8(opcodes[symbol]);
+    bw.writeU8(opcodes[symbol]);
   }
 
-  return this.fromRaw(p.render());
+  return this.fromRaw(bw.render());
 };
 
 /**
@@ -3420,14 +3421,14 @@ Script.checksig = function checksig(msg, sig, key, flags) {
 
 Script.sign = function sign(msg, key, type) {
   var sig = ec.sign(msg, key);
-  var p = new BufferWriter();
+  var bw = new BufferWriter();
 
   // Add the sighash type as a single byte
   // to the signature.
-  p.writeBytes(sig);
-  p.writeU8(type);
+  bw.writeBytes(sig);
+  bw.writeU8(type);
 
-  return p.render();
+  return bw.render();
 };
 
 /**
@@ -3471,56 +3472,56 @@ Script.fromRaw = function fromRaw(data, enc) {
  */
 
 Script.decode = function decode(raw) {
-  var p = new BufferReader(raw, true);
+  var br = new BufferReader(raw, true);
   var code = [];
   var op, size, data;
 
   assert(Buffer.isBuffer(raw));
 
-  while (p.left()) {
-    op = p.readU8();
+  while (br.left()) {
+    op = br.readU8();
     if (op >= 0x01 && op <= 0x4b) {
-      if (p.left() < op) {
+      if (br.left() < op) {
         code.push(new Opcode(-1));
         break;
       }
-      data = p.readBytes(op);
+      data = br.readBytes(op);
       code.push(new Opcode(op, data));
     } else if (op === opcodes.OP_PUSHDATA1) {
-      if (p.left() < 1) {
+      if (br.left() < 1) {
         code.push(new Opcode(-1));
         break;
       }
-      size = p.readU8();
-      if (p.left() < size) {
+      size = br.readU8();
+      if (br.left() < size) {
         code.push(new Opcode(-1));
         break;
       }
-      data = p.readBytes(size);
+      data = br.readBytes(size);
       code.push(new Opcode(op, data));
     } else if (op === opcodes.OP_PUSHDATA2) {
-      if (p.left() < 2) {
+      if (br.left() < 2) {
         code.push(new Opcode(-1));
         break;
       }
-      size = p.readU16();
-      if (p.left() < size) {
+      size = br.readU16();
+      if (br.left() < size) {
         code.push(new Opcode(-1));
         break;
       }
-      data = p.readBytes(size);
+      data = br.readBytes(size);
       code.push(new Opcode(op, data));
     } else if (op === opcodes.OP_PUSHDATA4) {
-      if (p.left() < 4) {
+      if (br.left() < 4) {
         code.push(new Opcode(-1));
         break;
       }
-      size = p.readU32();
-      if (p.left() < size) {
+      size = br.readU32();
+      if (br.left() < size) {
         code.push(new Opcode(-1));
         break;
       }
-      data = p.readBytes(size);
+      data = br.readBytes(size);
       code.push(new Opcode(op, data));
     } else {
       code.push(new Opcode(op));
@@ -3538,7 +3539,7 @@ Script.decode = function decode(raw) {
  */
 
 Script.encode = function encode(code, writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
   var i, op;
 
   assert(Array.isArray(code));
@@ -3551,33 +3552,33 @@ Script.encode = function encode(code, writer) {
 
     if (op.data) {
       if (op.value <= 0x4b) {
-        p.writeU8(op.data.length);
-        p.writeBytes(op.data);
+        bw.writeU8(op.data.length);
+        bw.writeBytes(op.data);
       } else if (op.value === opcodes.OP_PUSHDATA1) {
-        p.writeU8(opcodes.OP_PUSHDATA1);
-        p.writeU8(op.data.length);
-        p.writeBytes(op.data);
+        bw.writeU8(opcodes.OP_PUSHDATA1);
+        bw.writeU8(op.data.length);
+        bw.writeBytes(op.data);
       } else if (op.value === opcodes.OP_PUSHDATA2) {
-        p.writeU8(opcodes.OP_PUSHDATA2);
-        p.writeU16(op.data.length);
-        p.writeBytes(op.data);
+        bw.writeU8(opcodes.OP_PUSHDATA2);
+        bw.writeU16(op.data.length);
+        bw.writeBytes(op.data);
       } else if (op.value === opcodes.OP_PUSHDATA4) {
-        p.writeU8(opcodes.OP_PUSHDATA4);
-        p.writeU32(op.data.length);
-        p.writeBytes(op.data);
+        bw.writeU8(opcodes.OP_PUSHDATA4);
+        bw.writeU32(op.data.length);
+        bw.writeBytes(op.data);
       } else {
         throw new Error('Unknown pushdata opcode.');
       }
       continue;
     }
 
-    p.writeU8(op.value);
+    bw.writeU8(op.value);
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**

lib/script/witness.js

@@ -305,18 +305,18 @@ Witness.prototype.indexOf = function indexOf(data) {
  */
 
 Witness.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i;
 
-  p.writeVarint(this.items.length);
+  bw.writeVarint(this.items.length);
 
   for (i = 0; i < this.items.length; i++)
-    p.writeVarBytes(this.items[i]);
+    bw.writeVarBytes(this.items[i]);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -519,12 +519,12 @@ Witness.encodeItem = function encodeItem(data) {
  */
 
 Witness.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  var chunkCount = p.readVarint();
+  var br = BufferReader(data);
+  var chunkCount = br.readVarint();
   var i;
 
   for (i = 0; i < chunkCount; i++)
-    this.items.push(p.readVarBytes());
+    this.items.push(br.readVarBytes());
 
   return this;
 };

lib/utils/asn1.js

@@ -33,8 +33,8 @@ var assert = require('assert');
 var BufferReader = require('./reader');
 var ASN1 = exports;
 
-ASN1.parseTag = function parseTag(p) {
-  var tag = p.readU8();
+ASN1.parseTag = function parseTag(br) {
+  var tag = br.readU8();
   var primitive = (tag & 0x20) === 0;
   var oct;
 
@@ -42,7 +42,7 @@ ASN1.parseTag = function parseTag(p) {
     oct = tag;
     tag = 0;
     while ((oct & 0x80) === 0x80) {
-      oct = p.readU8();
+      oct = br.readU8();
       tag <<= 7;
       tag |= oct & 0x7f;
     }
@@ -53,12 +53,12 @@ ASN1.parseTag = function parseTag(p) {
   return {
     primitive: primitive,
     tag: tag,
-    len: ASN1.parseLen(p, primitive)
+    len: ASN1.parseLen(br, primitive)
   };
 };
 
-ASN1.parseLen = function parseLen(p, primitive) {
-  var len = p.readU8();
+ASN1.parseLen = function parseLen(br, primitive) {
+  var len = br.readU8();
   var num, i, j;
 
   // Indefinite form
@@ -78,7 +78,7 @@ ASN1.parseLen = function parseLen(p, primitive) {
   len = 0;
   for (i = 0; i < num; i++) {
     len <<= 8;
-    j = p.readU8();
+    j = br.readU8();
     len |= j;
   }
 
@@ -87,55 +87,55 @@ ASN1.parseLen = function parseLen(p, primitive) {
 
 ASN1.parseCert = function parseCert(data) {
   var d = BufferReader(data);
-  var p;
+  var br;
 
   d.start();
 
-  p = BufferReader(ASN1.parseSeq(d));
+  br = BufferReader(ASN1.parseSeq(d));
 
   return {
-    tbs: ASN1.parseTBS(p),
-    sigAlg: ASN1.parseAlgIdent(p),
-    sig: ASN1.parseBitstr(p),
+    tbs: ASN1.parseTBS(br),
+    sigAlg: ASN1.parseAlgIdent(br),
+    sig: ASN1.parseBitstr(br),
     raw: d.endData(true)
   };
 };
 
 ASN1.parseTBS = function parseTBS(data) {
   var d = BufferReader(data);
-  var p;
+  var br;
 
   d.start();
 
-  p = BufferReader(ASN1.parseSeq(d));
+  br = BufferReader(ASN1.parseSeq(d));
 
   return {
-    version: ASN1.parseExplicitInt(p, 0, true),
-    serial: ASN1.parseInt(p),
-    sig: ASN1.parseAlgIdent(p),
-    issuer: ASN1.parseName(p),
-    validity: ASN1.parseValidity(p),
-    subject: ASN1.parseName(p),
-    pubkey: ASN1.parsePubkey(p),
+    version: ASN1.parseExplicitInt(br, 0, true),
+    serial: ASN1.parseInt(br),
+    sig: ASN1.parseAlgIdent(br),
+    issuer: ASN1.parseName(br),
+    validity: ASN1.parseValidity(br),
+    subject: ASN1.parseName(br),
+    pubkey: ASN1.parsePubkey(br),
     raw: d.endData(true)
   };
 };
 
 ASN1.parseSeq = function parseSeq(data) {
-  var p = BufferReader(data);
-  var tag = ASN1.parseTag(p);
+  var br = BufferReader(data);
+  var tag = ASN1.parseTag(br);
   assert.equal(tag.tag, 0x10); // seq
-  return p.readBytes(tag.len, true);
+  return br.readBytes(tag.len, true);
 };
 
 ASN1.parseInt = function parseInt(data, readNum) {
-  var p = BufferReader(data);
-  var tag = ASN1.parseTag(p);
+  var br = BufferReader(data);
+  var tag = ASN1.parseTag(br);
   var num;
 
   assert.equal(tag.tag, 0x02); // int
 
-  num = p.readBytes(tag.len, true);
+  num = br.readBytes(tag.len, true);
 
   if (readNum)
     return num.readUIntBE(0, num.length);
@@ -144,29 +144,29 @@ ASN1.parseInt = function parseInt(data, readNum) {
 };
 
 ASN1.parseExplicitInt = function parseExplicitInt(data, i, readNum) {
-  var p = BufferReader(data);
-  var off = p.offset;
-  var tag = ASN1.parseTag(p);
+  var br = BufferReader(data);
+  var off = br.offset;
+  var tag = ASN1.parseTag(br);
   if (tag.tag !== i) {
-    p.seek(-(p.offset - off));
+    br.seek(-(br.offset - off));
     return -1;
   }
-  return ASN1.parseInt(p, readNum);
+  return ASN1.parseInt(br, readNum);
 };
 
 ASN1.parseBitstr = function parseBitstr(data) {
-  var p = BufferReader(data);
-  var tag = ASN1.parseTag(p);
+  var br = BufferReader(data);
+  var tag = ASN1.parseTag(br);
   assert.equal(tag.tag, 0x03); // bitstr
-  return ASN1.alignBitstr(p.readBytes(tag.len, true));
+  return ASN1.alignBitstr(br.readBytes(tag.len, true));
 };
 
 ASN1.parseString = function parseString(data) {
-  var p = BufferReader(data);
-  var tag = ASN1.parseTag(p);
+  var br = BufferReader(data);
+  var tag = ASN1.parseTag(br);
   switch (tag.tag) {
     case 0x03: // bitstr
-      return ASN1.alignBitstr(p.readBytes(tag.len, true));
+      return ASN1.alignBitstr(br.readBytes(tag.len, true));
     case 0x04: // octstr
     case 0x12: // numstr
     case 0x13: // prinstr
@@ -180,7 +180,7 @@ ASN1.parseString = function parseString(data) {
     case 0x1c: // unistr
     case 0x1d: // charstr
     case 0x1e: // bmpstr
-      return p.readString('utf8', tag.len);
+      return br.readString('utf8', tag.len);
     default:
       assert(false, 'Bad string.');
   }
@@ -208,29 +208,29 @@ ASN1.alignBitstr = function(data) {
 };
 
 ASN1.parsePubkey = function parsePubkey(data) {
-  var p = BufferReader(data);
-  p = BufferReader(ASN1.parseSeq(p));
+  var br = BufferReader(data);
+  br = BufferReader(ASN1.parseSeq(br));
   return {
-    alg: ASN1.parseAlgIdent(p),
-    pubkey: ASN1.parseBitstr(p)
+    alg: ASN1.parseAlgIdent(br),
+    pubkey: ASN1.parseBitstr(br)
   };
 };
 
 ASN1.parseName = function parseName(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var values = [];
   var tag;
 
-  p = BufferReader(ASN1.parseSeq(p));
+  br = BufferReader(ASN1.parseSeq(br));
 
-  while (p.left()) {
-    tag = ASN1.parseTag(p);
+  while (br.left()) {
+    tag = ASN1.parseTag(br);
     assert.equal(tag.tag, 0x11); // set
-    tag = ASN1.parseTag(p);
+    tag = ASN1.parseTag(br);
     assert.equal(tag.tag, 0x10); // seq
     values.push({
-      type: ASN1.parseOID(p),
-      value: ASN1.parseString(p)
+      type: ASN1.parseOID(br),
+      value: ASN1.parseString(br)
     });
   }
 
@@ -238,18 +238,18 @@ ASN1.parseName = function parseName(data) {
 };
 
 ASN1.parseValidity = function parseValidity(data) {
-  var p = BufferReader(data);
-  p = BufferReader(ASN1.parseSeq(p));
+  var br = BufferReader(data);
+  br = BufferReader(ASN1.parseSeq(br));
   return {
-    notBefore: ASN1.parseTime(p),
-    notAfter: ASN1.parseTime(p)
+    notBefore: ASN1.parseTime(br),
+    notAfter: ASN1.parseTime(br)
   };
 };
 
 ASN1.parseTime = function parseTime(data) {
-  var p = BufferReader(data);
-  var tag = ASN1.parseTag(p);
-  var str = p.readString('ascii', tag.len);
+  var br = BufferReader(data);
+  var tag = ASN1.parseTag(br);
+  var str = br.readString('ascii', tag.len);
   var year, mon, day, hour, min, sec;
 
   switch (tag.tag) {
@@ -282,8 +282,8 @@ ASN1.parseTime = function parseTime(data) {
 };
 
 ASN1.parseOID = function parseOID(data) {
-  var p = BufferReader(data);
-  var tag = ASN1.parseTag(p);
+  var br = BufferReader(data);
+  var tag = ASN1.parseTag(br);
   var ids = [];
   var ident = 0;
   var subident = 0;
@@ -291,11 +291,11 @@ ASN1.parseOID = function parseOID(data) {
 
   assert.equal(tag.tag, 0x06); // objid
 
-  objid = p.readBytes(tag.len, true);
-  p = BufferReader(objid);
+  objid = br.readBytes(tag.len, true);
+  br = BufferReader(objid);
 
-  while (p.left()) {
-    subident = p.readU8();
+  while (br.left()) {
+    subident = br.readU8();
     ident <<= 7;
     ident |= subident & 0x7f;
     if ((subident & 0x80) === 0) {
@@ -315,16 +315,16 @@ ASN1.parseOID = function parseOID(data) {
 };
 
 ASN1.parseAlgIdent = function parseAlgIdent(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var params = null;
   var alg;
 
-  p = BufferReader(ASN1.parseSeq(p));
+  br = BufferReader(ASN1.parseSeq(br));
 
-  alg = ASN1.parseOID(p);
+  alg = ASN1.parseOID(br);
 
-  if (p.left() > 0) {
-    params = p.readBytes(ASN1.parseTag(p).len, true);
+  if (br.left() > 0) {
+    params = br.readBytes(ASN1.parseTag(br).len, true);
     if (params.length === 0)
       params = null;
   }
@@ -336,26 +336,26 @@ ASN1.parseAlgIdent = function parseAlgIdent(data) {
 };
 
 ASN1.parseRSAPublic = function parseRSAPublic(data) {
-  var p = BufferReader(data);
-  p = BufferReader(ASN1.parseSeq(p));
+  var br = BufferReader(data);
+  br = BufferReader(ASN1.parseSeq(br));
   return {
-    modulus: ASN1.parseInt(p),
-    publicExponent: ASN1.parseInt(p)
+    modulus: ASN1.parseInt(br),
+    publicExponent: ASN1.parseInt(br)
   };
 };
 
 ASN1.parseRSAPrivate = function parseRSAPrivate(data) {
-  var p = BufferReader(data);
-  p = BufferReader(ASN1.parseSeq(p));
+  var br = BufferReader(data);
+  br = BufferReader(ASN1.parseSeq(br));
   return {
-    version: ASN1.parseInt(p, true),
-    modulus: ASN1.parseInt(p),
-    publicExponent: ASN1.parseInt(p),
-    privateExponent: ASN1.parseInt(p),
-    prime1: ASN1.parseInt(p),
-    prime2: ASN1.parseInt(p),
-    exponent1: ASN1.parseInt(p),
-    exponent2: ASN1.parseInt(p),
-    coefficient: ASN1.parseInt(p)
+    version: ASN1.parseInt(br, true),
+    modulus: ASN1.parseInt(br),
+    publicExponent: ASN1.parseInt(br),
+    privateExponent: ASN1.parseInt(br),
+    prime1: ASN1.parseInt(br),
+    prime2: ASN1.parseInt(br),
+    exponent1: ASN1.parseInt(br),
+    exponent2: ASN1.parseInt(br),
+    coefficient: ASN1.parseInt(br)
   };
 };

lib/utils/bloom.js

@@ -179,17 +179,17 @@ Bloom.fromRate = function fromRate(items, rate, update) {
  */
 
 Bloom.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  p.writeVarBytes(this.filter);
-  p.writeU32(this.n);
-  p.writeU32(this.tweak);
-  p.writeU8(this.update);
+  bw.writeVarBytes(this.filter);
+  bw.writeU32(this.n);
+  bw.writeU32(this.tweak);
+  bw.writeU8(this.update);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -199,12 +199,12 @@ Bloom.prototype.toRaw = function toRaw(writer) {
  */
 
 Bloom.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
 
-  this.filter = p.readVarBytes();
-  this.n = p.readU32();
-  this.tweak = p.readU32();
-  this.update = p.readU8();
+  this.filter = br.readVarBytes();
+  this.n = br.readU32();
+  this.tweak = br.readU32();
+  this.update = br.readU8();
 
   assert(constants.filterFlagsByVal[this.update] != null, 'Bad filter flag.');
 

lib/wallet/account.js

@@ -865,32 +865,32 @@ Account.prototype.toJSON = function toJSON(minimal) {
  */
 
 Account.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
   var i, key;
 
-  p.writeVarString(this.name, 'ascii');
-  p.writeU8(this.initialized ? 1 : 0);
-  p.writeU8(this.witness ? 1 : 0);
-  p.writeU8(this.type);
-  p.writeU8(this.m);
-  p.writeU8(this.n);
-  p.writeU32(this.accountIndex);
-  p.writeU32(this.receiveDepth);
-  p.writeU32(this.changeDepth);
-  p.writeU32(this.nestedDepth);
-  p.writeU8(this.lookahead);
-  p.writeBytes(this.accountKey.toRaw());
-  p.writeU8(this.keys.length);
+  bw.writeVarString(this.name, 'ascii');
+  bw.writeU8(this.initialized ? 1 : 0);
+  bw.writeU8(this.witness ? 1 : 0);
+  bw.writeU8(this.type);
+  bw.writeU8(this.m);
+  bw.writeU8(this.n);
+  bw.writeU32(this.accountIndex);
+  bw.writeU32(this.receiveDepth);
+  bw.writeU32(this.changeDepth);
+  bw.writeU32(this.nestedDepth);
+  bw.writeU8(this.lookahead);
+  bw.writeBytes(this.accountKey.toRaw());
+  bw.writeU8(this.keys.length);
 
   for (i = 0; i < this.keys.length; i++) {
     key = this.keys[i];
-    p.writeBytes(key.toRaw());
+    bw.writeBytes(key.toRaw());
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -901,28 +901,28 @@ Account.prototype.toRaw = function toRaw(writer) {
  */
 
 Account.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
   var i, count, key;
 
-  this.name = p.readVarString('ascii');
-  this.initialized = p.readU8() === 1;
-  this.witness = p.readU8() === 1;
-  this.type = p.readU8();
-  this.m = p.readU8();
-  this.n = p.readU8();
-  this.accountIndex = p.readU32();
-  this.receiveDepth = p.readU32();
-  this.changeDepth = p.readU32();
-  this.nestedDepth = p.readU32();
-  this.lookahead = p.readU8();
-  this.accountKey = HD.fromRaw(p.readBytes(82));
+  this.name = br.readVarString('ascii');
+  this.initialized = br.readU8() === 1;
+  this.witness = br.readU8() === 1;
+  this.type = br.readU8();
+  this.m = br.readU8();
+  this.n = br.readU8();
+  this.accountIndex = br.readU32();
+  this.receiveDepth = br.readU32();
+  this.changeDepth = br.readU32();
+  this.nestedDepth = br.readU32();
+  this.lookahead = br.readU8();
+  this.accountKey = HD.fromRaw(br.readBytes(82));
 
   assert(Account.typesByVal[this.type]);
 
-  count = p.readU8();
+  count = br.readU8();
 
   for (i = 0; i < count; i++) {
-    key = HD.fromRaw(p.readBytes(82));
+    key = HD.fromRaw(br.readBytes(82));
     this.pushKey(key);
   }
 

lib/wallet/client.js

@@ -377,15 +377,15 @@ WalletClient.prototype.rescan = function rescan(start) {
  */
 
 function parseEntry(data, enc) {
-  var p, block, hash;
+  var br, block, hash;
 
   if (typeof data === 'string')
     data = new Buffer(data, 'hex');
 
-  p = new BufferReader(data);
+  br = new BufferReader(data);
 
-  block = Headers.fromAbbr(p);
-  block.height = p.readU32();
+  block = Headers.fromAbbr(br);
+  block.height = br.readU32();
 
   hash = block.hash('hex');
 

lib/wallet/masterkey.js

@@ -446,31 +446,31 @@ MasterKey.prototype._encrypt = co(function* encrypt(passphrase, aes) {
  */
 
 MasterKey.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
   if (this.encrypted) {
-    p.writeU8(1);
-    p.writeVarBytes(this.iv);
-    p.writeVarBytes(this.ciphertext);
+    bw.writeU8(1);
+    bw.writeVarBytes(this.iv);
+    bw.writeVarBytes(this.ciphertext);
 
-    p.writeU8(this.alg);
-    p.writeU32(this.N);
-    p.writeU32(this.r);
-    p.writeU32(this.p);
+    bw.writeU8(this.alg);
+    bw.writeU32(this.N);
+    bw.writeU32(this.r);
+    bw.writeU32(this.p);
 
     if (!writer)
-      p = p.render();
+      bw = bw.render();
 
-    return p;
+    return bw;
   }
 
-  p.writeU8(0);
-  p.writeVarBytes(this.key.toExtended());
+  bw.writeU8(0);
+  bw.writeVarBytes(this.key.toExtended());
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -480,26 +480,26 @@ MasterKey.prototype.toRaw = function toRaw(writer) {
  */
 
 MasterKey.prototype.fromRaw = function fromRaw(raw) {
-  var p = new BufferReader(raw);
+  var br = new BufferReader(raw);
 
-  this.encrypted = p.readU8() === 1;
+  this.encrypted = br.readU8() === 1;
 
   if (this.encrypted) {
-    this.iv = p.readVarBytes();
-    this.ciphertext = p.readVarBytes();
+    this.iv = br.readVarBytes();
+    this.ciphertext = br.readVarBytes();
 
-    this.alg = p.readU8();
+    this.alg = br.readU8();
 
     assert(MasterKey.algByVal[this.alg]);
 
-    this.N = p.readU32();
-    this.r = p.readU32();
-    this.p = p.readU32();
+    this.N = br.readU32();
+    this.r = br.readU32();
+    this.p = br.readU32();
 
     return this;
   }
 
-  this.key = HD.fromExtended(p.readVarBytes());
+  this.key = HD.fromExtended(br.readVarBytes());
 
   return this;
 };

lib/wallet/path.js

@@ -132,19 +132,19 @@ Path.prototype.clone = function clone() {
  */
 
 Path.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
 
-  this.account = p.readU32();
-  this.keyType = p.readU8();
+  this.account = br.readU32();
+  this.keyType = br.readU8();
 
   switch (this.keyType) {
     case Path.types.HD:
-      this.branch = p.readU32();
-      this.index = p.readU32();
+      this.branch = br.readU32();
+      this.index = br.readU32();
       break;
     case Path.types.KEY:
-      this.encrypted = p.readU8() === 1;
-      this.data = p.readVarBytes();
+      this.encrypted = br.readU8() === 1;
+      this.data = br.readVarBytes();
       break;
     case Path.types.ADDRESS:
       // Hash will be passed in by caller.
@@ -154,8 +154,8 @@ Path.prototype.fromRaw = function fromRaw(data) {
       break;
   }
 
-  this.version = p.read8();
-  this.type = p.readU8();
+  this.version = br.read8();
+  this.type = br.readU8();
 
   return this;
 };
@@ -176,23 +176,23 @@ Path.fromRaw = function fromRaw(data) {
  */
 
 Path.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
-  p.writeU32(this.account);
-  p.writeU8(this.keyType);
+  bw.writeU32(this.account);
+  bw.writeU8(this.keyType);
 
   switch (this.keyType) {
     case Path.types.HD:
       assert(!this.data);
       assert(this.index !== -1);
-      p.writeU32(this.branch);
-      p.writeU32(this.index);
+      bw.writeU32(this.branch);
+      bw.writeU32(this.index);
       break;
     case Path.types.KEY:
       assert(this.data);
       assert(this.index === -1);
-      p.writeU8(this.encrypted ? 1 : 0);
-      p.writeVarBytes(this.data);
+      bw.writeU8(this.encrypted ? 1 : 0);
+      bw.writeVarBytes(this.data);
       break;
     case Path.types.ADDRESS:
       assert(!this.data);
@@ -203,13 +203,13 @@ Path.prototype.toRaw = function toRaw(writer) {
       break;
   }
 
-  p.write8(this.version);
-  p.writeU8(this.type);
+  bw.write8(this.version);
+  bw.writeU8(this.type);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**

lib/wallet/records.js

@@ -48,15 +48,15 @@ ChainState.prototype.clone = function clone() {
  */
 
 ChainState.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
 
-  this.startHeight = p.readU32();
-  this.startHash = p.readHash('hex');
-  this.height = p.readU32();
+  this.startHeight = br.readU32();
+  this.startHash = br.readHash('hex');
+  this.height = br.readU32();
   this.marked = true;
 
-  if (p.left() > 0)
-    this.marked = p.readU8() === 1;
+  if (br.left() > 0)
+    this.marked = br.readU8() === 1;
 
   return this;
 };
@@ -78,17 +78,17 @@ ChainState.fromRaw = function fromRaw(data) {
  */
 
 ChainState.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
-  p.writeU32(this.startHeight);
-  p.writeHash(this.startHash);
-  p.writeU32(this.height);
-  p.writeU8(this.marked ? 1 : 0);
+  bw.writeU32(this.startHeight);
+  bw.writeHash(this.startHash);
+  bw.writeU32(this.height);
+  bw.writeU8(this.marked ? 1 : 0);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -159,10 +159,10 @@ BlockMeta.prototype.fromJSON = function fromJSON(json) {
  */
 
 BlockMeta.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
-  this.hash = p.readHash('hex');
-  this.height = p.readU32();
-  this.ts = p.readU32();
+  var br = new BufferReader(data);
+  this.hash = br.readHash('hex');
+  this.height = br.readU32();
+  this.ts = br.readU32();
   return this;
 };
 
@@ -203,16 +203,16 @@ BlockMeta.fromRaw = function fromRaw(data) {
  */
 
 BlockMeta.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
-  p.writeHash(this.hash);
-  p.writeU32(this.height);
-  p.writeU32(this.ts);
+  bw.writeHash(this.hash);
+  bw.writeU32(this.height);
+  bw.writeU32(this.ts);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -252,13 +252,13 @@ function BlockMapRecord(height) {
  */
 
 BlockMapRecord.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
-  var count = p.readU32();
+  var br = new BufferReader(data);
+  var count = br.readU32();
   var i, hash, tx;
 
   for (i = 0; i < count; i++) {
-    hash = p.readHash('hex');
-    tx = TXMapRecord.fromRaw(hash, p);
+    hash = br.readHash('hex');
+    tx = TXMapRecord.fromRaw(hash, br);
     this.txs.push(tx);
     this.index[tx.hash] = tx;
   }
@@ -284,21 +284,21 @@ BlockMapRecord.fromRaw = function fromRaw(height, data) {
  */
 
 BlockMapRecord.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
   var i, tx;
 
-  p.writeU32(this.txs.length);
+  bw.writeU32(this.txs.length);
 
   for (i = 0; i < this.txs.length; i++) {
     tx = this.txs[i];
-    p.writeHash(tx.hash);
-    tx.toRaw(p);
+    bw.writeHash(tx.hash);
+    tx.toRaw(bw);
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -458,32 +458,32 @@ function cmpid(a, b) {
 }
 
 function parseWallets(data) {
-  var p = new BufferReader(data);
-  var count = p.readU32();
+  var br = new BufferReader(data);
+  var count = br.readU32();
   var wids = [];
   var i;
 
   for (i = 0; i < count; i++)
-    wids.push(p.readU32());
+    wids.push(br.readU32());
 
   return wids;
 }
 
 function serializeWallets(wids, writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
   var i, wid;
 
-  p.writeU32(wids.length);
+  bw.writeU32(wids.length);
 
   for (i = 0; i < wids.length; i++) {
     wid = wids[i];
-    p.writeU32(wid);
+    bw.writeU32(wid);
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 }
 
 /*

lib/wallet/txdb.js

@@ -2896,17 +2896,17 @@ TXDBState.prototype.toBalance = function toBalance() {
  */
 
 TXDBState.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
-  p.writeU64(this.tx);
-  p.writeU64(this.coin);
-  p.writeU64(this.unconfirmed);
-  p.writeU64(this.confirmed);
+  bw.writeU64(this.tx);
+  bw.writeU64(this.coin);
+  bw.writeU64(this.unconfirmed);
+  bw.writeU64(this.confirmed);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2917,11 +2917,11 @@ TXDBState.prototype.toRaw = function toRaw(writer) {
  */
 
 TXDBState.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
-  this.tx = p.readU53();
-  this.coin = p.readU53();
-  this.unconfirmed = p.readU53();
-  this.confirmed = p.readU53();
+  var br = new BufferReader(data);
+  this.tx = br.readU53();
+  this.coin = br.readU53();
+  this.unconfirmed = br.readU53();
+  this.confirmed = br.readU53();
   return this;
 };
 
@@ -2985,9 +2985,9 @@ function Credit(coin, spent) {
  */
 
 Credit.prototype.fromRaw = function fromRaw(data) {
-  var p = BufferReader(data);
-  this.coin.fromRaw(p);
-  this.spent = p.readU8() === 1;
+  var br = BufferReader(data);
+  this.coin.fromRaw(br);
+  this.spent = br.readU8() === 1;
   return this;
 };
 
@@ -3007,15 +3007,15 @@ Credit.fromRaw = function fromRaw(data) {
  */
 
 Credit.prototype.toRaw = function toRaw(writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
 
-  this.coin.toRaw(p);
-  p.writeU8(this.spent ? 1 : 0);
+  this.coin.toRaw(bw);
+  bw.writeU8(this.spent ? 1 : 0);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -3343,17 +3343,17 @@ BlockRecord.prototype.remove = function remove(hash) {
  */
 
 BlockRecord.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
   var i, hash, count;
 
-  this.hash = p.readHash('hex');
-  this.height = p.readU32();
-  this.ts = p.readU32();
+  this.hash = br.readHash('hex');
+  this.height = br.readU32();
+  this.ts = br.readU32();
 
-  count = p.readU32();
+  count = br.readU32();
 
   for (i = 0; i < count; i++) {
-    hash = p.readHash('hex');
+    hash = br.readHash('hex');
     this.index[hash] = true;
     this.hashes.push(hash);
   }
@@ -3378,22 +3378,22 @@ BlockRecord.fromRaw = function fromRaw(data) {
  */
 
 BlockRecord.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
   var i;
 
-  p.writeHash(this.hash);
-  p.writeU32(this.height);
-  p.writeU32(this.ts);
+  bw.writeHash(this.hash);
+  bw.writeU32(this.height);
+  bw.writeU32(this.ts);
 
-  p.writeU32(this.hashes.length);
+  bw.writeU32(this.hashes.length);
 
   for (i = 0; i < this.hashes.length; i++)
-    p.writeHash(this.hashes[i]);
+    bw.writeHash(this.hashes[i]);
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**

lib/wallet/wallet.js

@@ -611,26 +611,26 @@ Wallet.prototype.unlock = function unlock(passphrase, timeout) {
  */
 
 Wallet.prototype.getID = function getID() {
-  var p, key, hash;
+  var bw, key, hash;
 
   assert(this.master.key, 'Cannot derive id.');
 
   key = this.master.key.derive(44);
 
-  p = new BufferWriter();
-  p.writeBytes(key.publicKey);
-  p.writeU32(this.network.magic);
+  bw = new BufferWriter();
+  bw.writeBytes(key.publicKey);
+  bw.writeU32(this.network.magic);
 
-  hash = crypto.hash160(p.render());
+  hash = crypto.hash160(bw.render());
 
-  p = new BufferWriter();
-  p.writeU8(0x03);
-  p.writeU8(0xbe);
-  p.writeU8(0x04);
-  p.writeBytes(hash);
-  p.writeChecksum();
+  bw = new BufferWriter();
+  bw.writeU8(0x03);
+  bw.writeU8(0xbe);
+  bw.writeU8(0x04);
+  bw.writeBytes(hash);
+  bw.writeChecksum();
 
-  return base58.encode(p.render());
+  return base58.encode(bw.render());
 };
 
 /**
@@ -643,17 +643,17 @@ Wallet.prototype.getID = function getID() {
  */
 
 Wallet.prototype.getToken = function getToken(nonce) {
-  var p, key;
+  var bw, key;
 
   assert(this.master.key, 'Cannot derive token.');
 
   key = this.master.key.derive(44, true);
 
-  p = new BufferWriter();
-  p.writeBytes(key.privateKey);
-  p.writeU32(nonce);
+  bw = new BufferWriter();
+  bw.writeBytes(key.privateKey);
+  bw.writeU32(nonce);
 
-  return crypto.hash256(p.render());
+  return crypto.hash256(bw.render());
 };
 
 /**
@@ -2655,22 +2655,22 @@ Wallet.prototype.toJSON = function toJSON(unsafe) {
  */
 
 Wallet.prototype.toRaw = function toRaw(writer) {
-  var p = new BufferWriter(writer);
+  var bw = new BufferWriter(writer);
 
-  p.writeU32(this.network.magic);
-  p.writeU32(this.wid);
-  p.writeVarString(this.id, 'ascii');
-  p.writeU8(this.initialized ? 1 : 0);
-  p.writeU8(this.watchOnly ? 1 : 0);
-  p.writeU32(this.accountDepth);
-  p.writeBytes(this.token);
-  p.writeU32(this.tokenDepth);
-  p.writeVarBytes(this.master.toRaw());
+  bw.writeU32(this.network.magic);
+  bw.writeU32(this.wid);
+  bw.writeVarString(this.id, 'ascii');
+  bw.writeU8(this.initialized ? 1 : 0);
+  bw.writeU8(this.watchOnly ? 1 : 0);
+  bw.writeU32(this.accountDepth);
+  bw.writeBytes(this.token);
+  bw.writeU32(this.tokenDepth);
+  bw.writeVarBytes(this.master.toRaw());
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /**
@@ -2680,19 +2680,19 @@ Wallet.prototype.toRaw = function toRaw(writer) {
  */
 
 Wallet.prototype.fromRaw = function fromRaw(data) {
-  var p = new BufferReader(data);
+  var br = new BufferReader(data);
   var network;
 
-  network = Network.fromMagic(p.readU32());
+  network = Network.fromMagic(br.readU32());
 
-  this.wid = p.readU32();
-  this.id = p.readVarString('ascii');
-  this.initialized = p.readU8() === 1;
-  this.watchOnly = p.readU8() === 1;
-  this.accountDepth = p.readU32();
-  this.token = p.readBytes(32);
-  this.tokenDepth = p.readU32();
-  this.master.fromRaw(p.readVarBytes());
+  this.wid = br.readU32();
+  this.id = br.readVarString('ascii');
+  this.initialized = br.readU8() === 1;
+  this.watchOnly = br.readU8() === 1;
+  this.accountDepth = br.readU32();
+  this.token = br.readBytes(32);
+  this.tokenDepth = br.readU32();
+  this.master.fromRaw(br.readVarBytes());
 
   assert(network === this.db.network, 'Wallet network mismatch.');
 

lib/workers/framer.js

@@ -53,66 +53,66 @@ Framer.prototype.body = function body(items) {
 };
 
 Framer.item = function _item(item, writer) {
-  var p = BufferWriter(writer);
+  var bw = BufferWriter(writer);
   var i, keys;
 
   switch (typeof item) {
     case 'string':
-      p.writeU8(1);
-      p.writeVarString(item, 'utf8');
+      bw.writeU8(1);
+      bw.writeVarString(item, 'utf8');
       break;
     case 'number':
       if (item > 0x7fffffff) {
-        p.writeU8(3);
-        p.writeU32(item);
+        bw.writeU8(3);
+        bw.writeU32(item);
       } else {
-        p.writeU8(2);
-        p.write32(item);
+        bw.writeU8(2);
+        bw.write32(item);
       }
       break;
     case 'boolean':
-      p.writeU8(4);
-      p.writeU8(item ? 1 : 0);
+      bw.writeU8(4);
+      bw.writeU8(item ? 1 : 0);
       break;
     case 'object':
     case 'undefined':
       if (item == null) {
-        p.writeU8(0);
+        bw.writeU8(0);
         break;
       }
       if (item instanceof Script) {
-        p.writeU8(40);
-        p.writeVarBytes(item.toRaw());
+        bw.writeU8(40);
+        bw.writeVarBytes(item.toRaw());
       } else if (item instanceof Witness) {
-        p.writeU8(41);
-        item.toRaw(p);
+        bw.writeU8(41);
+        item.toRaw(bw);
       } else if (isMTX(item)) {
-        p.writeU8(42);
-        item.toExtended(true, p);
+        bw.writeU8(42);
+        item.toExtended(true, bw);
       } else if (isTX(item)) {
-        p.writeU8(43);
-        item.toExtended(true, p);
+        bw.writeU8(43);
+        item.toExtended(true, bw);
       } else if (item instanceof KeyRing) {
-        p.writeU8(44);
-        item.toRaw(p);
+        bw.writeU8(44);
+        item.toRaw(bw);
       } else if (BN.isBN(item)) {
-        p.writeU8(10);
-        p.writeVarBytes(item.toArrayLike(Buffer));
+        bw.writeU8(10);
+        bw.writeVarBytes(item.toArrayLike(Buffer));
       } else if (Buffer.isBuffer(item)) {
-        p.writeU8(5);
-        p.writeVarBytes(item);
+        bw.writeU8(5);
+        bw.writeVarBytes(item);
       } else if (Array.isArray(item)) {
-        p.writeU8(6);
-        p.writeVarint(item.length);
+        bw.writeU8(6);
+        bw.writeVarint(item.length);
         for (i = 0; i < item.length; i++)
-          Framer.item(item[i], p);
+          Framer.item(item[i], bw);
       } else {
         keys = Object.keys(item);
-        p.writeU8(7);
-        p.writeVarint(keys.length);
+        bw.writeU8(7);
+        bw.writeVarint(keys.length);
         for (i = 0; i < keys.length; i++) {
-          p.writeVarString(keys[i], 'utf8');
-          Framer.item(item[keys[i]], p);
+          bw.writeVarString(keys[i], 'utf8');
+          Framer.item(item[keys[i]], bw);
         }
       }
       break;
@@ -121,9 +121,9 @@ Framer.item = function _item(item, writer) {
   }
 
   if (!writer)
-    p = p.render();
+    bw = bw.render();
 
-  return p;
+  return bw;
 };
 
 /*

lib/workers/parser.js

@@ -144,46 +144,46 @@ Parser.prototype.parseHeader = function parseHeader(data) {
 };
 
 Parser.prototype.parseBody = function parseBody(data) {
-  var p = BufferReader(data);
+  var br = BufferReader(data);
   var i, count, items;
 
-  switch (p.readU8()) {
+  switch (br.readU8()) {
     case 0:
       return null;
     case 1:
-      return p.readVarString('utf8');
+      return br.readVarString('utf8');
     case 2:
-      return p.read32();
+      return br.read32();
     case 3:
-      return p.readU32();
+      return br.readU32();
     case 4:
-      return p.readU8() === 1;
+      return br.readU8() === 1;
     case 5:
-      return p.readVarBytes();
+      return br.readVarBytes();
     case 6:
       items = [];
-      count = p.readVarint();
+      count = br.readVarint();
       for (i = 0; i < count; i++)
-        items.push(this.parseBody(p));
+        items.push(this.parseBody(br));
       return items;
     case 7:
       items = {};
-      count = p.readVarint();
+      count = br.readVarint();
       for (i = 0; i < count; i++)
-        items[p.readVarString('utf8')] = this.parseBody(p);
+        items[br.readVarString('utf8')] = this.parseBody(br);
       return items;
     case 10:
-      return new BN(p.readVarBytes());
+      return new BN(br.readVarBytes());
     case 40:
-      return Script.fromRaw(p.readVarBytes());
+      return Script.fromRaw(br.readVarBytes());
     case 41:
-      return Witness.fromRaw(p);
+      return Witness.fromRaw(br);
     case 42:
-      return this.parseMTX(p);
+      return this.parseMTX(br);
     case 43:
-      return this.parseTX(p);
+      return this.parseTX(br);
     case 44:
-      return this.parseKeyRing(p);
+      return this.parseKeyRing(br);
     default:
       throw new Error('Bad type.');
   }