@opcat-labs/opcat 1.0.0

package/test/block/merklebloack.js

@@ -0,0 +1,211 @@
+'use strict';
+
+var should = require('chai').should();
+
+var opcat = require('../../index.js');
+var MerkleBlock = opcat.MerkleBlock;
+var BufferReader = opcat.encoding.BufferReader;
+var BufferWriter = opcat.encoding.BufferWriter;
+var Transaction = opcat.Transaction;
+var data = require('../data/merkleblocks.js');
+var transactionVector = require('../data/tx_creation');
+
+describe('MerkleBlock', function () {
+  var blockhex = data.HEX[0];
+  var blockbuf = Buffer.from(blockhex, 'hex');
+  var blockJSON = JSON.stringify(data.JSON[0]);
+  var blockObject = JSON.parse(JSON.stringify(data.JSON[0]));
+
+  describe('#constructor', function () {
+    it('should make a new merkleblock from buffer', function () {
+      var b = MerkleBlock(blockbuf);
+      b.toBuffer().toString('hex').should.equal(blockhex);
+    });
+
+    it('should make a new merkleblock from object', function () {
+      var b = MerkleBlock(blockObject);
+      b.toObject().should.deep.equal(blockObject);
+    });
+
+    it('should make a new merkleblock from JSON', function () {
+      var b = MerkleBlock(JSON.parse(blockJSON));
+      JSON.stringify(b).should.equal(blockJSON);
+    });
+
+    it('should not make an empty block', function () {
+      (function () {
+        return new MerkleBlock();
+      }).should.throw('Unrecognized argument for MerkleBlock');
+    });
+  });
+
+  describe('#fromObject', function () {
+    it('should set these known values', function () {
+      var block = MerkleBlock.fromObject(JSON.parse(blockJSON));
+      should.exist(block.header);
+      should.exist(block.numTransactions);
+      should.exist(block.hashes);
+      should.exist(block.flags);
+    });
+
+    it('should set these known values', function () {
+      var block = MerkleBlock(JSON.parse(blockJSON));
+      should.exist(block.header);
+      should.exist(block.numTransactions);
+      should.exist(block.hashes);
+      should.exist(block.flags);
+    });
+
+    it('accepts an object as argument', function () {
+      var block = MerkleBlock(blockbuf);
+      should.exist(MerkleBlock.fromObject(block.toObject()));
+    });
+  });
+
+  describe('#toJSON', function () {
+    it('should recover these known values', function () {
+      var block = new MerkleBlock(JSON.parse(blockJSON));
+      var b = JSON.parse(JSON.stringify(block));
+      should.exist(block.header);
+      should.exist(block.numTransactions);
+      should.exist(block.hashes);
+      should.exist(block.flags);
+      should.exist(b.header);
+      should.exist(b.numTransactions);
+      should.exist(b.hashes);
+      should.exist(b.flags);
+    });
+  });
+
+  describe('#fromBuffer', function () {
+    it('should make a block from this known buffer', function () {
+      var block = MerkleBlock.fromBuffer(blockbuf);
+      block.toBuffer().toString('hex').should.equal(blockhex);
+    });
+  });
+
+  describe('#fromBufferReader', function () {
+    it('should make a block from this known buffer', function () {
+      var block = MerkleBlock.fromBufferReader(BufferReader(blockbuf));
+      block.toBuffer().toString('hex').should.equal(blockhex);
+    });
+  });
+
+  describe('#toBuffer', function () {
+    it('should recover a block from this known buffer', function () {
+      var block = MerkleBlock.fromBuffer(blockbuf);
+      block.toBuffer().toString('hex').should.equal(blockhex);
+    });
+  });
+
+  describe('#toBufferWriter', function () {
+    it('should recover a block from this known buffer', function () {
+      var block = MerkleBlock.fromBuffer(blockbuf);
+      block.toBufferWriter().concat().toString('hex').should.equal(blockhex);
+    });
+
+    it("doesn't create a bufferWriter if one provided", function () {
+      var writer = new BufferWriter();
+      var block = MerkleBlock.fromBuffer(blockbuf);
+      block.toBufferWriter(writer).should.equal(writer);
+    });
+  });
+
+  describe('#validMerkleTree', function () {
+    it('should validate good merkleblocks', function () {
+      data.JSON.forEach(function (data) {
+        var b = MerkleBlock(data);
+        b.validMerkleTree().should.equal(true);
+      });
+    });
+
+    it('should not validate merkleblocks with too many hashes', function () {
+      var b = MerkleBlock(data.JSON[0]);
+      // Add too many hashes
+      var i = 0;
+      while (i <= b.numTransactions) {
+        b.hashes.push('bad' + i++);
+      }
+      b.validMerkleTree().should.equal(false);
+    });
+
+    it('should not validate merkleblocks with too few bit flags', function () {
+      var b = MerkleBlock(JSON.parse(blockJSON));
+      b.flags.pop();
+      b.validMerkleTree().should.equal(false);
+    });
+  });
+
+  describe('#filteredTxsHash', function () {
+    it('should validate good merkleblocks', function () {
+      var hashOfFilteredTx = '6f64fd5aa9dd01f74c03656d376625cf80328d83d9afebe60cc68b8f0e245bd9';
+      var b = MerkleBlock(data.JSON[3]);
+      b.filteredTxsHash()[0].should.equal(hashOfFilteredTx);
+    });
+
+    it('should fail with merkleblocks with too many hashes', function () {
+      var b = MerkleBlock(data.JSON[0]);
+      // Add too many hashes
+      var i = 0;
+      while (i <= b.numTransactions) {
+        b.hashes.push('bad' + i++);
+      }
+      (function () {
+        b.filteredTxsHash();
+      }).should.throw('This MerkleBlock contain an invalid Merkle Tree');
+    });
+
+    it('should fail with merkleblocks with too few bit flags', function () {
+      var b = MerkleBlock(JSON.parse(blockJSON));
+      b.flags.pop();
+      (function () {
+        b.filteredTxsHash();
+      }).should.throw('This MerkleBlock contain an invalid Merkle Tree');
+    });
+  });
+
+  describe('#hasTransaction', function () {
+    it('should find transactions via hash string', function () {
+      var jsonData = data.JSON[0];
+      var txId = Buffer.from(jsonData.hashes[1], 'hex').toString('hex');
+      var b = MerkleBlock(jsonData);
+      b.hasTransaction(txId + 'abcd').should.equal(false);
+    });
+
+    it('should find transactions via Transaction object', function () {
+      // TODO: update data.TXHEX[0][0]
+      // var jsonData = data.JSON[0];
+      // var txBuf = Buffer.from(data.TXHEX[0][0], 'hex');
+      // var tx = new Transaction().fromBuffer(txBuf);
+      // var b = MerkleBlock(jsonData);
+      // b.hasTransaction(tx).should.equal(true);
+    });
+
+    it('should not find non-existant Transaction object', function () {
+      // TODO: update data.TXHEX[0][0]
+      // Reuse another transaction already in data/ dir
+      // var serialized = transactionVector[0][7];
+      // var tx = new Transaction().fromBuffer(Buffer.from(serialized, 'hex'));
+      // var b = MerkleBlock(data.JSON[0]);
+      // b.validMerkleTree().should.equal(true);
+      // b.hasTransaction(tx).should.equal(false);
+    });
+
+    it('should not match with merkle nodes', function () {
+      var b = MerkleBlock(data.JSON[0]);
+
+
+
+      var hashData = [
+        ['3612262624047ee87660be1a707519a443b1c1ce3d248cbfc6c15870f6c5daa2', false],
+        ['019f5b01d4195ecbc9398fbf3c3b1fa9bb3183301d7a1fb3bd174fcfa40a2b65', true],
+        ['41ed70551dd7e841883ab8f0b16bf04176b7d1480e4f0af9f3d4c3595768d068', false],
+        ['20d2a7bc994987302e5b1ac80fc425fe25f8b63169ea78e68fbaaefa59379bbf', false],
+      ];
+
+      hashData.forEach(function check(d) {
+        b.hasTransaction(d[0]).should.equal(d[1]);
+      });
+    });
+  });
+});

package/test/crypto/bn.js

@@ -0,0 +1,177 @@
+'use strict';
+
+var should = require('chai').should();
+var opcat = require('../..');
+var BN = opcat.crypto.BN;
+
+describe('BN', function () {
+  it('should create a bn', function () {
+    var bn = new BN(50);
+    should.exist(bn);
+    bn.toString().should.equal('50');
+  });
+
+  it('should parse this number', function () {
+    var bn = new BN(999970000);
+    bn.toString().should.equal('999970000');
+  });
+
+  it('should parse numbers below and at bn.js internal word size', function () {
+    var bn = new BN(Math.pow(2, 26) - 1);
+    bn.toString().should.equal((Math.pow(2, 26) - 1).toString());
+    bn = new BN(Math.pow(2, 26));
+    bn.toString().should.equal(Math.pow(2, 26).toString());
+  });
+
+  describe('#add', function () {
+    it('should add two small numbers together', function () {
+      var bn1 = new BN(50);
+      var bn2 = new BN(75);
+      var bn3 = bn1.add(bn2);
+      bn3.toString().should.equal('125');
+    });
+  });
+
+  describe('#sub', function () {
+    it('should subtract a small number', function () {
+      var bn1 = new BN(50);
+      var bn2 = new BN(25);
+      var bn3 = bn1.sub(bn2);
+      bn3.toString().should.equal('25');
+    });
+  });
+
+  describe('#gt', function () {
+    it('should say 1 is greater than 0', function () {
+      var bn1 = new BN(1);
+      var bn0 = new BN(0);
+      bn1.gt(bn0).should.equal(true);
+    });
+
+    it('should say a big number is greater than a small big number', function () {
+      var bn1 = new BN('24023452345398529485723980457');
+      var bn0 = new BN('34098234283412341234049357');
+      bn1.gt(bn0).should.equal(true);
+    });
+
+    it('should say a big number is great than a standard number', function () {
+      var bn1 = new BN('24023452345398529485723980457');
+      var bn0 = new BN(5);
+      bn1.gt(bn0).should.equal(true);
+    });
+  });
+
+  describe('to/from ScriptNumBuffer', function () {
+    [0, 1, 10, 256, 1000, 65536, 65537, -1, -1000, -65536, -65537].forEach(function (n) {
+      it('rountrips correctly for ' + n, function () {
+        BN.fromScriptNumBuffer(new BN(n).toScriptNumBuffer()).toNumber().should.equal(n);
+      });
+    });
+  });
+
+  describe('#fromString', function () {
+    it('should make BN from a string', function () {
+      BN.fromString('5').toString().should.equal('5');
+    });
+    it('should work with hex string', function () {
+      BN.fromString('7fffff0000000000000000000000000000000000000000000000000000000000', 16)
+        .toString(16)
+        .should.equal('7fffff0000000000000000000000000000000000000000000000000000000000');
+    });
+  });
+
+  describe('#toString', function () {
+    it('should make a string', function () {
+      new BN(5).toString().should.equal('5');
+    });
+  });
+
+  describe('@fromBuffer', function () {
+    it('should work with big endian', function () {
+      var bn = BN.fromBuffer(Buffer.from('0001', 'hex'), {
+        endian: 'big',
+      });
+      bn.toString().should.equal('1');
+    });
+
+    it('should work with big endian 256', function () {
+      var bn = BN.fromBuffer(Buffer.from('0100', 'hex'), {
+        endian: 'big',
+      });
+      bn.toString().should.equal('256');
+    });
+
+    it('should work with little endian if we specify the size', function () {
+      var bn = BN.fromBuffer(Buffer.from('0100', 'hex'), {
+        size: 2,
+        endian: 'little',
+      });
+      bn.toString().should.equal('1');
+    });
+  });
+
+  describe('#toBuffer', function () {
+    it('should create a 4 byte buffer', function () {
+      var bn = new BN(1);
+      bn.toBuffer({
+        size: 4,
+      })
+        .toString('hex')
+        .should.equal('00000001');
+    });
+
+    it('should create a 4 byte buffer in little endian', function () {
+      var bn = new BN(1);
+      bn.toBuffer({
+        size: 4,
+        endian: 'little',
+      })
+        .toString('hex')
+        .should.equal('01000000');
+    });
+
+    it('should create a 2 byte buffer even if you ask for a 1 byte', function () {
+      var bn = new BN('ff00', 16);
+      bn.toBuffer({
+        size: 1,
+      })
+        .toString('hex')
+        .should.equal('ff00');
+    });
+
+    it('should create a 4 byte buffer even if you ask for a 1 byte', function () {
+      var bn = new BN('ffffff00', 16);
+      bn.toBuffer({
+        size: 4,
+      })
+        .toString('hex')
+        .should.equal('ffffff00');
+    });
+  });
+
+  describe('@fromHex', function () {
+    it('should work with big endian', function () {
+      var bn = BN.fromHex('0001', {
+        endian: 'big',
+      });
+      bn.toString().should.equal('1');
+    });
+
+    it('should work with little endian if we specify the size', function () {
+      var bn = BN.fromHex('0100', {
+        size: 2,
+        endian: 'little',
+      });
+      bn.toString().should.equal('1');
+    });
+  });
+
+  describe('#toHex', function () {
+    it('should create a 4 byte he string', function () {
+      var bn = new BN(1);
+      bn.toHex({
+        size: 4,
+      }).should.equal('00000001');
+    });
+  });
+});