@opcat-labs/opcat 1.0.0

package/test/encoding/bufferreader.js

@@ -0,0 +1,337 @@
+'use strict';
+
+var should = require('chai').should();
+var opcat = require('../..');
+var BufferWriter = opcat.encoding.BufferWriter;
+var BufferReader = opcat.encoding.BufferReader;
+var BN = opcat.crypto.BN;
+
+describe('BufferReader', function () {
+  it('should make a new BufferReader', function () {
+    var br = new BufferReader();
+    should.exist(br);
+    br = BufferReader();
+    should.exist(br);
+  });
+
+  it('should create a new bufferreader with a buffer', function () {
+    var buf = Buffer.alloc(0);
+    var br = new BufferReader(buf);
+    should.exist(br);
+    Buffer.isBuffer(br.buf).should.equal(true);
+  });
+  it('should fail for invalid object', function () {
+    var fail = function () {
+      return new BufferReader(5);
+    };
+    fail.should.throw('Unrecognized argument for BufferReader');
+  });
+
+  describe('#set', function () {
+    it('should set pos', function () {
+      should.exist(
+        BufferReader().set({
+          pos: 1,
+        }).pos,
+      );
+    });
+  });
+
+  describe('#eof', function () {
+    it('should return true for a blank br', function () {
+      var br = new BufferReader(Buffer.from([]));
+      br.finished().should.equal(true);
+    });
+  });
+
+  describe('read', function () {
+    it('should return the same buffer', function () {
+      var buf = Buffer.from([0]);
+      var br = new BufferReader(buf);
+      br.readAll().toString('hex').should.equal(buf.toString('hex'));
+    });
+
+    it('should return a buffer of this length', function () {
+      var buf = Buffer.alloc(10);
+      buf.fill(0);
+      var br = new BufferReader(buf);
+      var buf2 = br.read(2);
+      buf2.length.should.equal(2);
+      br.finished().should.equal(false);
+      br.pos.should.equal(2);
+    });
+
+    it('should work with 0 length', function () {
+      var buf = Buffer.alloc(10);
+      buf.fill(1);
+      var br = new BufferReader(buf);
+      var buf2 = br.read(0);
+      buf2.length.should.equal(0);
+      br.finished().should.equal(false);
+      buf2.toString('hex').should.equal('');
+    });
+  });
+
+  describe('readVarLengthBuffer', function () {
+    it('returns correct buffer', function () {
+      var buf = Buffer.from(
+        '73010000003766404f00000000b305434f00000000f203' +
+          '0000f1030000001027000048ee00000064000000004653656520626974636f696' +
+          'e2e6f72672f666562323020696620796f7520686176652074726f75626c652063' +
+          '6f6e6e656374696e6720616674657220323020466562727561727900473045022' +
+          '1008389df45f0703f39ec8c1cc42c13810ffcae14995bb648340219e353b63b53' +
+          'eb022009ec65e1c1aaeec1fd334c6b684bde2b3f573060d5b70c3a46723326e4e' +
+          '8a4f1',
+        'hex',
+      );
+      var br = new BufferReader(buf);
+      var b1 = br.readVarLengthBuffer();
+      b1.toString('hex').should.equal(
+        '010000003766404f00000000b305434f000' +
+          '00000f2030000f1030000001027000048ee000000640000000046536565206269' +
+          '74636f696e2e6f72672f666562323020696620796f7520686176652074726f756' +
+          '26c6520636f6e6e656374696e6720616674657220323020466562727561727900',
+      );
+      var b2 = br.readVarLengthBuffer();
+      b2.toString('hex').should.equal(
+        '30450221008389df45f0703f39ec8c1cc42' +
+          'c13810ffcae14995bb648340219e353b63b53eb022009ec65e1c1aaeec1fd334c' +
+          '6b684bde2b3f573060d5b70c3a46723326e4e8a4f1',
+      );
+    });
+    it('fails on length too big', function () {
+      var buf = Buffer.from('0a00', 'hex');
+      var br = new BufferReader(buf);
+      br.readVarLengthBuffer.bind(br).should.throw('Invalid length while reading varlength buffer');
+    });
+  });
+
+  describe('#readUInt8', function () {
+    it('should return 1', function () {
+      var buf = Buffer.alloc(1);
+      buf.writeUInt8(1, 0);
+      var br = new BufferReader(buf);
+      br.readUInt8().should.equal(1);
+    });
+  });
+
+  describe('#readUInt16BE', function () {
+    it('should return 1', function () {
+      var buf = Buffer.alloc(2);
+      buf.writeUInt16BE(1, 0);
+      var br = new BufferReader(buf);
+      br.readUInt16BE().should.equal(1);
+    });
+  });
+
+  describe('#readUInt16LE', function () {
+    it('should return 1', function () {
+      var buf = Buffer.alloc(2);
+      buf.writeUInt16LE(1, 0);
+      var br = new BufferReader(buf);
+      br.readUInt16LE().should.equal(1);
+    });
+  });
+
+  describe('#readUInt32BE', function () {
+    it('should return 1', function () {
+      var buf = Buffer.alloc(4);
+      buf.writeUInt32BE(1, 0);
+      var br = new BufferReader(buf);
+      br.readUInt32BE().should.equal(1);
+    });
+  });
+
+  describe('#readUInt32LE', function () {
+    it('should return 1', function () {
+      var buf = Buffer.alloc(4);
+      buf.writeUInt32LE(1, 0);
+      var br = new BufferReader(buf);
+      br.readUInt32LE().should.equal(1);
+    });
+  });
+
+  describe('#readUInt64BEBN', function () {
+    it('should return 1', function () {
+      var buf = Buffer.alloc(8);
+      buf.fill(0);
+      buf.writeUInt32BE(1, 4);
+      var br = new BufferReader(buf);
+      br.readUInt64BEBN().toNumber().should.equal(1);
+    });
+
+    it('should return 2^64', function () {
+      var buf = Buffer.alloc(8);
+      buf.fill(0xff);
+      var br = new BufferReader(buf);
+      br.readUInt64BEBN().toNumber().should.equal(Math.pow(2, 64));
+    });
+  });
+
+  describe('#readUInt64LEBN', function () {
+    it('should return 1', function () {
+      var buf = Buffer.alloc(8);
+      buf.fill(0);
+      buf.writeUInt32LE(1, 0);
+      var br = new BufferReader(buf);
+      br.readUInt64LEBN().toNumber().should.equal(1);
+    });
+
+    it('should return 10 OPCAT', function () {
+      var tenopcat = 10 * 1e8;
+      var tenopcatBuffer = Buffer.from('00ca9a3b00000000', 'hex');
+      var br = new BufferReader(tenopcatBuffer);
+      br.readUInt64LEBN().toNumber().should.equal(tenopcat);
+    });
+
+    it('should return 2^30', function () {
+      var buf = Buffer.alloc(8);
+      buf.fill(0);
+      buf.writeUInt32LE(Math.pow(2, 30), 0);
+      var br = new BufferReader(buf);
+      br.readUInt64LEBN().toNumber().should.equal(Math.pow(2, 30));
+    });
+
+    it('should return 2^32 + 1', function () {
+      var num = Math.pow(2, 32) + 1;
+      var numBuffer = Buffer.from('0100000001000000', 'hex');
+      var br = new BufferReader(numBuffer);
+      br.readUInt64LEBN().toNumber().should.equal(num);
+    });
+
+    it('should return max number of satoshis', function () {
+      var maxSatoshis = 21000000 * 1e8;
+      var maxSatoshisBuffer = Buffer.from('0040075af0750700', 'hex');
+      var br = new BufferReader(maxSatoshisBuffer);
+      br.readUInt64LEBN().toNumber().should.equal(maxSatoshis);
+    });
+
+    it('should return 2^53 - 1', function () {
+      var maxSafe = Math.pow(2, 53) - 1;
+      var maxSafeBuffer = Buffer.from('ffffffffffff1f00', 'hex');
+      var br = new BufferReader(maxSafeBuffer);
+      br.readUInt64LEBN().toNumber().should.equal(maxSafe);
+    });
+
+    it('should return 2^53', function () {
+      var bn = new BN('20000000000000', 16);
+      var bnBuffer = Buffer.from('0000000000002000', 'hex');
+      var br = new BufferReader(bnBuffer);
+      var readbn = br.readUInt64LEBN();
+      readbn.cmp(bn).should.equal(0);
+    });
+
+    it('should return 0', function () {
+      var buf = Buffer.alloc(8);
+      buf.fill(0);
+      var br = new BufferReader(buf);
+      br.readUInt64LEBN().toNumber().should.equal(0);
+    });
+
+    it('should return 2^64', function () {
+      var buf = Buffer.alloc(8);
+      buf.fill(0xff);
+      var br = new BufferReader(buf);
+      br.readUInt64LEBN().toNumber().should.equal(Math.pow(2, 64));
+    });
+  });
+
+  describe('#readVarintBuf', function () {
+    it('should read a 1 byte varint', function () {
+      var buf = Buffer.from([50]);
+      var br = new BufferReader(buf);
+      br.readVarintBuf().length.should.equal(1);
+    });
+
+    it('should read a 3 byte varint', function () {
+      var buf = Buffer.from([253, 253, 0]);
+      var br = new BufferReader(buf);
+      br.readVarintBuf().length.should.equal(3);
+    });
+
+    it('should read a 5 byte varint', function () {
+      var buf = Buffer.from([254, 0, 0, 0, 0]);
+      buf.writeUInt32LE(50000, 1);
+      var br = new BufferReader(buf);
+      br.readVarintBuf().length.should.equal(5);
+    });
+
+    it('should read a 9 byte varint', function () {
+      var buf = new BufferWriter().writeVarintBN(new BN(Math.pow(2, 54).toString())).concat();
+      var br = new BufferReader(buf);
+      br.readVarintBuf().length.should.equal(9);
+    });
+  });
+
+  describe('#readVarintNum', function () {
+    it('should read a 1 byte varint', function () {
+      var buf = Buffer.from([50]);
+      var br = new BufferReader(buf);
+      br.readVarintNum().should.equal(50);
+    });
+
+    it('should read a 3 byte varint', function () {
+      var buf = Buffer.from([253, 253, 0]);
+      var br = new BufferReader(buf);
+      br.readVarintNum().should.equal(253);
+    });
+
+    it('should read a 5 byte varint', function () {
+      var buf = Buffer.from([254, 0, 0, 0, 0]);
+      buf.writeUInt32LE(50000, 1);
+      var br = new BufferReader(buf);
+      br.readVarintNum().should.equal(50000);
+    });
+
+    it('should throw an error on a 9 byte varint over the javascript uint precision limit', function () {
+      var buf = new BufferWriter().writeVarintBN(new BN(Math.pow(2, 54).toString())).concat();
+      var br = new BufferReader(buf);
+      (function () {
+        br.readVarintNum();
+      }).should.throw('number too large to retain precision - use readVarintBN');
+    });
+
+    it('should not throw an error on a 9 byte varint not over the javascript uint precision limit', function () {
+      var buf = new BufferWriter().writeVarintBN(new BN(Math.pow(2, 53).toString())).concat();
+      var br = new BufferReader(buf);
+      (function () {
+        br.readVarintNum();
+      }).should.not.throw('number too large to retain precision - use readVarintBN');
+    });
+  });
+
+  describe('#readVarintBN', function () {
+    it('should read a 1 byte varint', function () {
+      var buf = Buffer.from([50]);
+      var br = new BufferReader(buf);
+      br.readVarintBN().toNumber().should.equal(50);
+    });
+
+    it('should read a 3 byte varint', function () {
+      var buf = Buffer.from([253, 253, 0]);
+      var br = new BufferReader(buf);
+      br.readVarintBN().toNumber().should.equal(253);
+    });
+
+    it('should read a 5 byte varint', function () {
+      var buf = Buffer.from([254, 0, 0, 0, 0]);
+      buf.writeUInt32LE(50000, 1);
+      var br = new BufferReader(buf);
+      br.readVarintBN().toNumber().should.equal(50000);
+    });
+
+    it('should read a 9 byte varint', function () {
+      var buf = Buffer.concat([Buffer.from([255]), Buffer.from('ffffffffffffffff', 'hex')]);
+      var br = new BufferReader(buf);
+      br.readVarintBN().toNumber().should.equal(Math.pow(2, 64));
+    });
+  });
+
+  describe('#reverse', function () {
+    it('should reverse this [0, 1]', function () {
+      var buf = Buffer.from([0, 1]);
+      var br = new BufferReader(buf);
+      br.reverse().readAll().toString('hex').should.equal('0100');
+    });
+  });
+});

package/test/encoding/bufferwriter.js

@@ -0,0 +1,172 @@
+'use strict';
+
+var opcat = require('../..');
+var should = require('chai').should();
+var expect = require('chai').expect;
+var BufferWriter = opcat.encoding.BufferWriter;
+var BufferReader = opcat.encoding.BufferReader;
+var BN = opcat.crypto.BN;
+
+describe('BufferWriter', function () {
+  it('should create a new buffer writer', function () {
+    var bw = new BufferWriter();
+    should.exist(bw);
+  });
+
+  describe('#set', function () {
+    it('set bufs', function () {
+      var buf1 = Buffer.from([0]);
+      var buf2 = Buffer.from([1]);
+      var bw = new BufferWriter().set({ bufs: [buf1, buf2] });
+      bw.concat().toString('hex').should.equal('0001');
+    });
+  });
+
+  describe('#toBuffer', function () {
+    it('should concat these two bufs', function () {
+      var buf1 = Buffer.from([0]);
+      var buf2 = Buffer.from([1]);
+      var bw = new BufferWriter({ bufs: [buf1, buf2] });
+      bw.toBuffer().toString('hex').should.equal('0001');
+    });
+  });
+
+  describe('#concat', function () {
+    it('should concat these two bufs', function () {
+      var buf1 = Buffer.from([0]);
+      var buf2 = Buffer.from([1]);
+      var bw = new BufferWriter({ bufs: [buf1, buf2] });
+      bw.concat().toString('hex').should.equal('0001');
+    });
+  });
+
+  describe('#write', function () {
+    it('should write a buffer', function () {
+      var buf = Buffer.from([0]);
+      var bw = new BufferWriter();
+      bw.write(buf);
+      bw.concat().toString('hex').should.equal('00');
+    });
+  });
+
+  describe('#writeUInt8', function () {
+    it('should write 1', function () {
+      var bw = new BufferWriter();
+      bw.writeUInt8(1).concat().toString('hex').should.equal('01');
+    });
+  });
+
+  describe('#writeUInt16BE', function () {
+    it('should write 1', function () {
+      var bw = new BufferWriter();
+      bw.writeUInt16BE(1).concat().toString('hex').should.equal('0001');
+    });
+  });
+
+  describe('#writeUInt16LE', function () {
+    it('should write 1', function () {
+      var bw = new BufferWriter();
+      bw.writeUInt16LE(1).concat().toString('hex').should.equal('0100');
+    });
+  });
+
+  describe('#writeUInt32BE', function () {
+    it('should write 1', function () {
+      var bw = new BufferWriter();
+      bw.writeUInt32BE(1).concat().toString('hex').should.equal('00000001');
+    });
+  });
+
+  describe('#writeUInt32LE', function () {
+    it('should write 1', function () {
+      var bw = new BufferWriter();
+      bw.writeUInt32LE(1).concat().toString('hex').should.equal('01000000');
+    });
+  });
+
+  describe('#writeUInt64BEBN', function () {
+    it('should write 1', function () {
+      var bw = new BufferWriter();
+      bw.writeUInt64BEBN(new BN(1)).concat().toString('hex').should.equal('0000000000000001');
+    });
+  });
+
+  describe('#writeUInt64LEBN', function () {
+    it('should write 1', function () {
+      var bw = new BufferWriter();
+      bw.writeUInt64LEBN(new BN(1)).concat().toString('hex').should.equal('0100000000000000');
+    });
+  });
+
+  describe('#writeVarint', function () {
+    it('should write a 1 byte varint', function () {
+      var bw = new BufferWriter();
+      bw.writeVarintNum(1);
+      bw.concat().length.should.equal(1);
+    });
+
+    it('should write a 3 byte varint', function () {
+      var bw = new BufferWriter();
+      bw.writeVarintNum(1000);
+      bw.concat().length.should.equal(3);
+    });
+
+    it('should write a 5 byte varint', function () {
+      var bw = new BufferWriter();
+      bw.writeVarintNum(Math.pow(2, 16 + 1));
+      bw.concat().length.should.equal(5);
+    });
+
+    it('should write a 9 byte varint', function () {
+      var bw = new BufferWriter();
+      bw.writeVarintNum(Math.pow(2, 32 + 1));
+      bw.concat().length.should.equal(9);
+    });
+
+    it('should read back the same value it wrote for a 8 byte varint', function () {
+      var bw = new BufferWriter();
+      var n = Math.pow(2, 53);
+      n.should.equal(n + 1); // javascript number precision limit
+      bw.writeVarintNum(n - 1);
+      var br = new BufferReader({ buf: bw.concat() });
+      br.readVarintBN()
+        .toNumber()
+        .should.equal(n - 1);
+    });
+
+    it('should throw for a 9 byte varint', function () {
+      expect(function () {
+        var bw = new BufferWriter();
+        var n = Math.pow(2, 53);
+        n.should.equal(n + 1); // javascript number precision limit
+        bw.writeVarintNum(n);
+      }).to.throw('varint too large');
+    });
+  });
+
+  describe('#writeVarintBN', function () {
+    it('should write a 1 byte varint', function () {
+      var bw = new BufferWriter();
+      bw.writeVarintBN(new BN(1));
+      bw.concat().length.should.equal(1);
+    });
+
+    it('should write a 3 byte varint', function () {
+      var bw = new BufferWriter();
+      bw.writeVarintBN(new BN(1000));
+      bw.concat().length.should.equal(3);
+    });
+
+    it('should write a 5 byte varint', function () {
+      var bw = new BufferWriter();
+      bw.writeVarintBN(new BN(Math.pow(2, 16 + 1)));
+      bw.concat().length.should.equal(5);
+    });
+
+    it('should write a 9 byte varint', function () {
+      var bw = new BufferWriter();
+      bw.writeVarintBN(new BN(Math.pow(2, 32 + 1)));
+      bw.concat().length.should.equal(9);
+    });
+  });
+});

package/test/encoding/varint.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var should = require('chai').should();
+var opcat = require('../..');
+var BN = opcat.crypto.BN;
+var BufferReader = opcat.encoding.BufferReader;
+var BufferWriter = opcat.encoding.BufferWriter;
+var Varint = opcat.encoding.Varint;
+
+describe('Varint', function () {
+  it('should make a new varint', function () {
+    var buf = Buffer.from('00', 'hex');
+    var varint = new Varint(buf);
+    should.exist(varint);
+    varint.buf.toString('hex').should.equal('00');
+    varint = Varint(buf);
+    should.exist(varint);
+    varint.buf.toString('hex').should.equal('00');
+
+    // various ways to use the constructor
+    Varint(Varint(0).toBuffer()).toNumber().should.equal(0);
+    Varint(0).toNumber().should.equal(0);
+    Varint(new BN(0)).toNumber().should.equal(0);
+  });
+
+  describe('#set', function () {
+    it('should set a buffer', function () {
+      var buf = Buffer.from('00', 'hex');
+      var varint = Varint().set({ buf: buf });
+      varint.buf.toString('hex').should.equal('00');
+      varint.set({});
+      varint.buf.toString('hex').should.equal('00');
+    });
+  });
+
+  describe('#fromString', function () {
+    it('should set a buffer', function () {
+      var buf = new BufferWriter().writeVarintNum(5).concat();
+      var varint = Varint().fromString(buf.toString('hex'));
+      varint.toNumber().should.equal(5);
+    });
+  });
+
+  describe('#toString', function () {
+    it('should return a buffer', function () {
+      var buf = new BufferWriter().writeVarintNum(5).concat();
+      var varint = Varint().fromString(buf.toString('hex'));
+      varint.toString().should.equal('05');
+    });
+  });
+
+  describe('#fromBuffer', function () {
+    it('should set a buffer', function () {
+      var buf = new BufferWriter().writeVarintNum(5).concat();
+      var varint = Varint().fromBuffer(buf);
+      varint.toNumber().should.equal(5);
+    });
+  });
+
+  describe('#fromBufferReader', function () {
+    it('should set a buffer reader', function () {
+      var buf = new BufferWriter().writeVarintNum(5).concat();
+      var br = BufferReader(buf);
+      var varint = Varint().fromBufferReader(br);
+      varint.toNumber().should.equal(5);
+    });
+  });
+
+  describe('#fromBN', function () {
+    it('should set a number', function () {
+      var varint = Varint().fromBN(new BN(5));
+      varint.toNumber().should.equal(5);
+    });
+  });
+
+  describe('#fromNumber', function () {
+    it('should set a number', function () {
+      var varint = Varint().fromNumber(5);
+      varint.toNumber().should.equal(5);
+    });
+  });
+
+  describe('#toBuffer', function () {
+    it('should return a buffer', function () {
+      var buf = new BufferWriter().writeVarintNum(5).concat();
+      var varint = Varint(buf);
+      varint.toBuffer().toString('hex').should.equal(buf.toString('hex'));
+    });
+  });
+
+  describe('#toBN', function () {
+    it('should return a buffer', function () {
+      var varint = Varint(5);
+      varint.toBN().toString().should.equal(new BN(5).toString());
+    });
+  });
+
+  describe('#toNumber', function () {
+    it('should return a buffer', function () {
+      var varint = Varint(5);
+      varint.toNumber().should.equal(5);
+    });
+  });
+});

package/test/hashCache.js

@@ -0,0 +1,67 @@
+'use strict';
+var HashCache = require('../lib/hash-cache');
+var chai = require('chai');
+var should = chai.should();
+
+describe('HashCache', function () {
+  const prevoutsHashBuf = Buffer.from('01'.repeat(32), 'hex');
+  const sequenceHashBuf = Buffer.from('02'.repeat(32), 'hex');
+  const outputsHashBuf = Buffer.from('03'.repeat(32), 'hex');
+
+  it('should satisfy this basic API', function () {
+    const hashCache = new HashCache(prevoutsHashBuf, sequenceHashBuf, outputsHashBuf);
+    should.exist(hashCache);
+    hashCache.prevoutsHashBuf.length.should.equal(32);
+    hashCache.sequenceHashBuf.length.should.equal(32);
+    hashCache.outputsHashBuf.length.should.equal(32);
+  });
+
+  describe('#fromBuffer', function () {
+    it('should parse this known message', function () {
+      const hashCache = HashCache.fromBuffer(
+        new HashCache(prevoutsHashBuf, sequenceHashBuf, outputsHashBuf).toBuffer(),
+      );
+      hashCache
+        .toHex()
+        .should.equal(
+          '7b22707265766f75747348617368427566223a2230313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031222c2273657175656e636548617368427566223a2230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032222c226f75747075747348617368427566223a2230333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033227d',
+        );
+    });
+  });
+
+  describe('#toBuffer', function () {
+    it('should parse this known message', function () {
+      const hashCache = new HashCache(prevoutsHashBuf, sequenceHashBuf, outputsHashBuf);
+      hashCache
+        .toBuffer()
+        .toString('hex')
+        .should.equal(
+          '7b22707265766f75747348617368427566223a2230313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031222c2273657175656e636548617368427566223a2230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032222c226f75747075747348617368427566223a2230333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033227d',
+        );
+    });
+  });
+
+  describe('#fromJSON', function () {
+    it('should parse this known json hashCache', function () {
+      HashCache.fromJSON(
+        JSON.parse(
+          '{"prevoutsHashBuf":"0101010101010101010101010101010101010101010101010101010101010101","sequenceHashBuf":"0202020202020202020202020202020202020202020202020202020202020202","outputsHashBuf":"0303030303030303030303030303030303030303030303030303030303030303"}',
+        ),
+      )
+        .toHex()
+        .should.equal(
+          '7b22707265766f75747348617368427566223a2230313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031222c2273657175656e636548617368427566223a2230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032222c226f75747075747348617368427566223a2230333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033303330333033227d',
+        );
+    });
+  });
+
+  describe('#toJSON', function () {
+    it('should create this known message', function () {
+      JSON.stringify(
+        new HashCache(prevoutsHashBuf, sequenceHashBuf, outputsHashBuf).toJSON(),
+      ).should.equal(
+        '{"prevoutsHashBuf":"0101010101010101010101010101010101010101010101010101010101010101","sequenceHashBuf":"0202020202020202020202020202020202020202020202020202020202020202","outputsHashBuf":"0303030303030303030303030303030303030303030303030303030303030303"}',
+      );
+    });
+  });
+});