refactor(bufferutils): backport BufferReader

The upstream PR that introduced BufferWriter has had some significant
changes: bitcoinjs/bitcoinjs-lib#1533

In particular, we now also have BufferReader. Also we can and should
use both classes in many more places.

Subclass BufferReader with `ZcashBufferReader` and implement
`readInt64()` there.

Replace fixtures for `readInt64()` with
`test/forks/zcash/bufferutils.js`.

Issue: BG-16466

Author: OttoAllmendinger

package.json

@@ -19,7 +19,7 @@
   "scripts": {
     "coverage-report": "nyc report --reporter=lcov",
     "coverage-html": "nyc report --reporter=html",
-    "coverage": "BITGO_UTXO_LIB_TEST_EXPECTED_COUNT=3436 nyc --check-coverage --branches 90 --functions 90 mocha --recursive",
+    "coverage": "BITGO_UTXO_LIB_TEST_EXPECTED_COUNT=3442 nyc --check-coverage --branches 90 --functions 90 mocha --recursive",
     "integration": "mocha test/integration/",
     "standard": "standard",
     "test": "npm run standard && npm run coverage",

src/buffer_writer.js

@@ -1,39 +1,141 @@
+/* eslint-disable */
+const types = require('./types');
+const typeforce = require('typeforce');
+const varuint = require('varuint-bitcoin');
 // https://github.com/feross/buffer/blob/master/index.js#L1127
-function verifuint (value, max) {
-  if (typeof value !== 'number') throw new Error('cannot write a non-number as a number')
-  if (value < 0) throw new Error('specified a negative value for writing an unsigned value')
-  if (value > max) throw new Error('RangeError: value out of range')
-  if (Math.floor(value) !== value) throw new Error('value has a fractional component')
+function verifuint(value, max) {
+    if (typeof value !== 'number')
+        throw new Error('cannot write a non-number as a number');
+    if (value < 0)
+        throw new Error('specified a negative value for writing an unsigned value');
+    if (value > max)
+        throw new Error('RangeError: value out of range');
+    if (Math.floor(value) !== value)
+        throw new Error('value has a fractional component');
 }
-
-function readUInt64LE (buffer, offset) {
-  var a = buffer.readUInt32LE(offset)
-  var b = buffer.readUInt32LE(offset + 4)
-  b *= 0x100000000
-
-  verifuint(b + a, 0x001fffffffffffff)
-
-  return b + a
+function readUInt64LE(buffer, offset) {
+    const a = buffer.readUInt32LE(offset);
+    let b = buffer.readUInt32LE(offset + 4);
+    b *= 0x100000000;
+    verifuint(b + a, 0x001fffffffffffff);
+    return b + a;
 }
-
-function readInt64LE (buffer, offset) {
-  var a = buffer.readUInt32LE(offset)
-  var b = buffer.readInt32LE(offset + 4)
-  b *= 0x100000000
-
-  return b + a
+function writeUInt64LE(buffer, value, offset) {
+    verifuint(value, 0x001fffffffffffff);
+    buffer.writeInt32LE(value & -1, offset);
+    buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4);
+    return offset + 8;
 }
-
-function writeUInt64LE (buffer, value, offset) {
-  verifuint(value, 0x001fffffffffffff)
-
-  buffer.writeInt32LE(value & -1, offset)
-  buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4)
-  return offset + 8
+function reverseBuffer(buffer) {
+    if (buffer.length < 1)
+        return buffer;
+    let j = buffer.length - 1;
+    let tmp = 0;
+    for (let i = 0; i < buffer.length / 2; i++) {
+        tmp = buffer[i];
+        buffer[i] = buffer[j];
+        buffer[j] = tmp;
+        j--;
+    }
+    return buffer;
 }
-
-module.exports = {
-  readUInt64LE: readUInt64LE,
-  readInt64LE: readInt64LE,
-  writeUInt64LE: writeUInt64LE
+/**
+ * Helper class for serialization of bitcoin data types into a pre-allocated buffer.
+ */
+class BufferWriter {
+    constructor(buffer, offset = 0) {
+        this.buffer = buffer;
+        this.offset = offset;
+        typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
+    }
+    writeUInt8(i) {
+        this.offset = this.buffer.writeUInt8(i, this.offset);
+    }
+    writeInt32(i) {
+        this.offset = this.buffer.writeInt32LE(i, this.offset);
+    }
+    writeUInt32(i) {
+        this.offset = this.buffer.writeUInt32LE(i, this.offset);
+    }
+    writeUInt64(i) {
+        this.offset = writeUInt64LE(this.buffer, i, this.offset);
+    }
+    writeVarInt(i) {
+        varuint.encode(i, this.buffer, this.offset);
+        this.offset += varuint.encode.bytes;
+    }
+    writeSlice(slice) {
+        if (this.buffer.length < this.offset + slice.length) {
+            throw new Error('Cannot write slice out of bounds');
+        }
+        this.offset += slice.copy(this.buffer, this.offset);
+    }
+    writeVarSlice(slice) {
+        this.writeVarInt(slice.length);
+        this.writeSlice(slice);
+    }
+    writeVector(vector) {
+        this.writeVarInt(vector.length);
+        vector.forEach((buf) => this.writeVarSlice(buf));
+    }
+}
+/**
+ * Helper class for reading of bitcoin data types from a buffer.
+ */
+class BufferReader {
+    constructor(buffer, offset = 0) {
+        this.buffer = buffer;
+        this.offset = offset;
+        typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
+    }
+    readUInt8() {
+        const result = this.buffer.readUInt8(this.offset);
+        this.offset++;
+        return result;
+    }
+    readInt32() {
+        const result = this.buffer.readInt32LE(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    readUInt32() {
+        const result = this.buffer.readUInt32LE(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    readUInt64() {
+        const result = readUInt64LE(this.buffer, this.offset);
+        this.offset += 8;
+        return result;
+    }
+    readVarInt() {
+        const vi = varuint.decode(this.buffer, this.offset);
+        this.offset += varuint.decode.bytes;
+        return vi;
+    }
+    readSlice(n) {
+        if (this.buffer.length < this.offset + n) {
+            throw new Error('Cannot read slice out of bounds');
+        }
+        const result = this.buffer.slice(this.offset, this.offset + n);
+        this.offset += n;
+        return result;
+    }
+    readVarSlice() {
+        return this.readSlice(this.readVarInt());
+    }
+    readVector() {
+        const count = this.readVarInt();
+        const vector = [];
+        for (let i = 0; i < count; i++)
+            vector.push(this.readVarSlice());
+        return vector;
+    }
 }
+module.exports = {
+    readUInt64LE,
+    writeUInt64LE,
+    reverseBuffer,
+    BufferWriter,
+    BufferReader,
+};

src/bufferutils.js

@@ -0,0 +1,13 @@
+const { BufferReader } = require('../../bufferutils')
+
+class ZcashBufferReader extends BufferReader {
+  readInt64 () {
+    const a = this.buffer.readUInt32LE(this.offset)
+    let b = this.buffer.readInt32LE(this.offset + 4)
+    b *= 0x100000000
+    this.offset += 8
+    return b + a
+  }
+}
+
+module.exports = { ZcashBufferReader }