refactor(block): use BufferReader/BufferWriter

Tracking upstream change
bitcoinjs/bitcoinjs-lib@f48abd3

Issue: BG-16466

Author: OttoAllmendinger

src/block.js

@@ -3,6 +3,7 @@ var bcrypto = require('./crypto')
 var fastMerkleRoot = require('merkle-lib/fastRoot')
 var typeforce = require('typeforce')
 var types = require('./types')
+var bufferutils = require('./bufferutils')
 var varuint = require('varuint-bitcoin')
 var networks = require('./networks')
 var coins = require('./coins')
@@ -33,57 +34,35 @@ Block.fromBuffer = function (buffer, network) {
   if (buffer.length < 80) throw new Error('Buffer too small (< 80 bytes)')
   network = network || networks.bitcoin
 
-  var offset = 0
-  function readSlice (n) {
-    offset += n
-    return buffer.slice(offset - n, offset)
-  }
-
-  function readUInt32 () {
-    var i = buffer.readUInt32LE(offset)
-    offset += 4
-    return i
-  }
-
-  function readInt32 () {
-    var i = buffer.readInt32LE(offset)
-    offset += 4
-    return i
-  }
-
-  function readVarInt () {
-    var vi = varuint.decode(buffer, offset)
-    offset += varuint.decode.bytes
-    return vi
-  }
+  const bufferReader = new bufferutils.BufferReader(buffer)
 
   var block = new Block(network)
-  block.version = readInt32()
-  block.prevHash = readSlice(32)
-  block.merkleRoot = readSlice(32)
+  block.version = bufferReader.readInt32()
+  block.prevHash = bufferReader.readSlice(32)
+  block.merkleRoot = bufferReader.readSlice(32)
   if (coins.isZcash(network)) {
-    block.finalSaplingRoot = readSlice(32)
+    block.finalSaplingRoot = bufferReader.readSlice(32)
   }
-  block.timestamp = readUInt32()
-  block.bits = readUInt32()
+  block.timestamp = bufferReader.readUInt32()
+  block.bits = bufferReader.readUInt32()
   if (coins.isZcash(network)) {
-    block.nonce = readSlice(32)
-    block.solutionSize = readVarInt()
-    block.solution = readSlice(1344)
+    block.nonce = bufferReader.readSlice(32)
+    block.solutionSize = bufferReader.readVarInt()
+    block.solution = bufferReader.readSlice(1344)
   } else {
     // Not sure sure why the nonce is read as UInt 32 and not as a slice
-    block.nonce = readUInt32()
+    block.nonce = bufferReader.readUInt32()
   }
 
-  if (buffer.length === 80) return block
+  if (bufferReader.buffer.length === 80) return block
 
   function readTransaction () {
-    var tx = Transaction.fromBuffer(buffer.slice(offset), network, true)
-    offset += tx.byteLength()
+    var tx = Transaction.fromBuffer(buffer.slice(bufferReader.offset), network, true)
+    bufferReader.offset += tx.byteLength()
     return tx
   }
 
-  var nTransactions = readVarInt()
+  var nTransactions = bufferReader.readVarInt()
   block.transactions = []
 
   for (var i = 0; i < nTransactions; ++i) {
@@ -135,49 +114,38 @@ Block.prototype.getUTCDate = function () {
 // TODO: buffer, offset compatibility
 Block.prototype.toBuffer = function (headersOnly) {
   var buffer = Buffer.allocUnsafe(this.byteLength(headersOnly))
+  var bufferWriter = new bufferutils.BufferWriter(buffer)
 
-  var offset = 0
-  function writeSlice (slice) {
-    slice.copy(buffer, offset)
-    offset += slice.length
-  }
-
-  function writeInt32 (i) {
-    buffer.writeInt32LE(i, offset)
-    offset += 4
-  }
-  function writeUInt32 (i) {
-    buffer.writeUInt32LE(i, offset)
-    offset += 4
-  }
-
-  writeInt32(this.version)
-  writeSlice(this.prevHash)
-  writeSlice(this.merkleRoot)
+  bufferWriter.writeInt32(this.version)
+  bufferWriter.writeSlice(this.prevHash)
+  bufferWriter.writeSlice(this.merkleRoot)
   if (coins.isZcash(this.network)) {
-    writeSlice(this.finalSaplingRoot)
+    bufferWriter.writeSlice(this.finalSaplingRoot)
   }
-  writeUInt32(this.timestamp)
-  writeUInt32(this.bits)
+  bufferWriter.writeUInt32(this.timestamp)
+  bufferWriter.writeUInt32(this.bits)
   if (coins.isZcash(this.network)) {
-    writeSlice(this.nonce)
-    varuint.encode(this.solutionSize, buffer, offset)
-    offset += varuint.encode.bytes
-    writeSlice(this.solution)
+    bufferWriter.writeSlice(this.nonce)
+    // TODO: use writeVarInt
+    varuint.encode(this.solutionSize, bufferWriter.buffer, bufferWriter.offset)
+    bufferWriter.offset += varuint.encode.bytes
+    bufferWriter.writeSlice(this.solution)
   } else {
     // Not sure sure why the nonce is interpreted as UInt 32 and not a slice in bitcoin
-    writeUInt32(this.nonce)
+    bufferWriter.writeUInt32(this.nonce)
   }
 
   if (headersOnly || !this.transactions) return buffer
 
-  varuint.encode(this.transactions.length, buffer, offset)
-  offset += varuint.encode.bytes
+  // TODO: use writeVarInt
+  varuint.encode(this.transactions.length, bufferWriter.buffer, bufferWriter.offset)
+  bufferWriter.offset += varuint.encode.bytes
 
+  // TODO: use writeVarInt
   this.transactions.forEach(function (tx) {
     var txSize = tx.byteLength() // TODO: extract from toBuffer?
-    tx.toBuffer(buffer, offset)
-    offset += txSize
+    tx.toBuffer(bufferWriter.buffer, bufferWriter.offset)
+    bufferWriter.offset += txSize
   })
 
   return buffer