@opcat-labs/opcat 1.0.0

package/test/transaction/deserialize.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var Transaction = require('../../lib/transaction');
+
+var vectorsValid = require('../data/bitcoind/tx_valid.json');
+var vectorsInvalid = require('../data/bitcoind/tx_invalid.json');
+
+describe('Transaction deserialization', function () {
+  describe('valid transaction test case', function () {
+    var index = 0;
+    vectorsValid.forEach(function (vector) {
+      it('vector #' + index, function () {
+        if (vector.length > 1) {
+          var hexa = vector[1];
+          Transaction(hexa).serialize(true).should.equal(hexa);
+          index++;
+        }
+      });
+    });
+  });
+  describe('invalid transaction test case', function () {
+    // TODO: 
+    // var index = 0;
+    // vectorsInvalid.forEach(function (vector) {
+    //   it('invalid vector #' + index, function () {
+    //     if (vector.length > 1) {
+    //       var hexa = vector[1];
+    //       Transaction(hexa).serialize(true).should.equal(hexa);
+    //       index++;
+    //     }
+    //   });
+    // });
+  });
+});

package/test/transaction/input/input.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var should = require('chai').should();
+var expect = require('chai').expect;
+
+var opcat = require('../../..');
+var PrivateKey = opcat.PrivateKey;
+var Address = opcat.Address;
+var Script = opcat.Script;
+var Networks = opcat.Networks;
+var Input = opcat.Transaction.Input;
+
+describe('Transaction.Input', function () {
+  var privateKey = new PrivateKey('KwF9LjRraetZuEjR8VqEq539z137LW5anYDUnVK11vM3mNMHTWb4');
+  var publicKey = privateKey.publicKey;
+  var address = new Address(publicKey, Networks.livenet);
+  var output = {
+    address: '33zbk2aSZYdNbRsMPPt6jgy6Kq1kQreqeb',
+    prevTxId: '66e64ef8a3b384164b78453fa8c8194de9a473ba14f89485a0e433699daec140',
+    outputIndex: 0,
+    script: new Script(address),
+    satoshis: 1000000,
+  };
+  var coinbase = {
+    prevTxId: '0000000000000000000000000000000000000000000000000000000000000000',
+    outputIndex: 0xffffffff,
+    script: new Script(),
+    satoshis: 1000000,
+  };
+
+  var coinbaseJSON = JSON.stringify({
+    prevTxId: '0000000000000000000000000000000000000000000000000000000000000000',
+    outputIndex: 4294967295,
+    script: '',
+  });
+
+  it('has abstract methods: "getSignatures", "isFullySigned", "addSignature", "clearSignatures"', function () {
+    // var input = new Input(output)
+    // _.each(['getSignatures', 'isFullySigned', 'addSignature', 'clearSignatures'], function (method) {
+    //   expect(function () {
+    //     return input[method]()
+    //   }).to.throw(errors.AbstractMethodInvoked)
+    // })
+  });
+  it('detects coinbase transactions', function () {
+    new Input(output).isNull().should.equal(false);
+    var ci = new Input(coinbase);
+    ci.isNull().should.equal(true);
+  });
+
+  describe('instantiation', function () {
+    it('works without new', function () {
+      var input = Input();
+      should.exist(input);
+    });
+    it('fails with no script info', function () {
+      expect(function () {
+        var input = new Input({});
+        input.toString();
+      }).to.throw('Invalid params: require prevTxId and outputIndex.');
+    });
+    it('fromObject should work', function () {
+      var jsonData = JSON.parse(coinbaseJSON);
+      var input = Input.fromObject(jsonData);
+      should.exist(input);
+      input.prevTxId.toString('hex').should.equal(jsonData.prevTxId);
+      input.outputIndex.should.equal(jsonData.outputIndex);
+    });
+    it('fromObject should work', function () {
+      var input = Input.fromObject(JSON.parse(coinbaseJSON));
+      var obj = input.toObject();
+      Input.fromObject(obj).should.deep.equal(input);
+      obj.script = 42;
+      Input.fromObject.bind(null, obj).should.throw('Invalid argument type: script');
+    });
+  });
+
+  it('_estimateSize returns correct size', function () {
+    var input = new Input(output);
+    input._estimateSize().should.equal(66);
+  });
+
+  it('defaults isFinal correctly', function () {
+    new Input(output).isFinal().should.equal(true);
+  });
+
+  it('handles isFinal when sequence number is set to non default value', function () {
+    new Input({ ...output, sequenceNumber: 0 }).isFinal().should.equal(false);
+  });
+});

package/test/transaction/input/multisig.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var should = require('chai').should();
+var _ = require('../../../lib/util/_');
+
+var opcat = require('../../..');
+var Transaction = opcat.Transaction;
+var PrivateKey = opcat.PrivateKey;
+var Script = opcat.Script;
+var MultiSigInput = opcat.Transaction.Input.MultiSig;
+
+describe('MultiSigInput', function () {
+  var privateKey1 = new PrivateKey('KwF9LjRraetZuEjR8VqEq539z137LW5anYDUnVK11vM3mNMHTWb4');
+  var privateKey2 = new PrivateKey('L4PqnaPTCkYhAqH3YQmefjxQP6zRcF4EJbdGqR8v6adtG9XSsadY');
+  var privateKey3 = new PrivateKey('L4CTX79zFeksZTyyoFuPQAySfmP7fL3R41gWKTuepuN7hxuNuJwV');
+  var public1 = privateKey1.publicKey;
+  var public2 = privateKey2.publicKey;
+  var public3 = privateKey3.publicKey;
+  var output = {
+    txId: '66e64ef8a3b384164b78453fa8c8194de9a473ba14f89485a0e433699daec140',
+    outputIndex: 0,
+    script: new Script(
+      '5221025c95ec627038e85b5688a9b3d84d28c5ebe66e8c8d697d498e20fe96e3b1ab1d2102cdddfc974d41a62f1f80081deee70592feb7d6e6cf6739d6592edbe7946720e72103c95924e02c240b5545089c69c6432447412b58be43fd671918bd184a5009834353ae',
+    ),
+    satoshis: 1000000,
+  };
+ 
+  it('can parse list of signature buffers, from TX signed with key 1 and 2', function () {
+    var transaction = new Transaction(
+      '010000000140c1ae9d6933e4a08594f814ba73a4e94d19c8a83f45784b1684b3a3f84ee66600000000920047304402207031af27ed2b2440f11b803e0c311c257f5b69b94d1b231428d7157085d7f6c20220132dbdebaa417c2f54790bcdcc3730bd1b943fe9aa71e504b13be674111eecd301483045022100f6f1d3c135ac3ff8a81614a56142cf5aa68efde447955373980f8fc73068f3bb0220497f40851cc930a7783159fde902108ad3d936879413e448b7fcb7803930663d01ffffffff0140420f000000000017a91419438da7d16709643be5abd8df62ca4034a489a7870000000000',
+    );
+
+    var inputObj = transaction.inputs[0].toObject();
+    inputObj.output = output;
+    transaction.inputs[0] = new Transaction.Input(inputObj);
+
+    inputObj.signatures = MultiSigInput.normalizeSignatures(
+      transaction,
+      transaction.inputs[0],
+      0,
+      transaction.inputs[0].script.chunks.slice(1).map(function (s) {
+        return s.buf;
+      }),
+      [public1, public2, public3],
+    );
+
+    transaction.inputs[0] = new MultiSigInput(inputObj, [public1, public2, public3], 2);
+
+    transaction.inputs[0].signatures[0].publicKey.should.deep.equal(public1);
+    transaction.inputs[0].signatures[1].publicKey.should.deep.equal(public2);
+    should.equal(transaction.inputs[0].signatures[2], undefined);
+    transaction.inputs[0]
+      .isValidSignature(transaction, transaction.inputs[0].signatures[0])
+      .should.equal(true);
+    transaction.inputs[0]
+      .isValidSignature(transaction, transaction.inputs[0].signatures[1])
+      .should.equal(true);
+  });
+  it('can parse list of signature buffers, from TX signed with key 3 and 1', function () {
+    var transaction = new Transaction(
+      '010000000140c1ae9d6933e4a08594f814ba73a4e94d19c8a83f45784b1684b3a3f84ee66600000000910047304402207031af27ed2b2440f11b803e0c311c257f5b69b94d1b231428d7157085d7f6c20220132dbdebaa417c2f54790bcdcc3730bd1b943fe9aa71e504b13be674111eecd301473044022059e3652eb43cb42a65f633dd6ecd1014350a164f89cb44104f926b93affbe09f02206bdf93eddf0c2fadd9ea1b9ab273f90e15a03e821fe5de87e457d1940b569dc001ffffffff0140420f000000000017a91419438da7d16709643be5abd8df62ca4034a489a7870000000000',
+    );
+
+    var inputObj = transaction.inputs[0].toObject();
+    inputObj.output = output;
+    transaction.inputs[0] = new Transaction.Input(inputObj);
+
+    inputObj.signatures = MultiSigInput.normalizeSignatures(
+      transaction,
+      transaction.inputs[0],
+      0,
+      transaction.inputs[0].script.chunks.slice(1).map(function (s) {
+        return s.buf;
+      }),
+      [public1, public2, public3],
+    );
+
+    transaction.inputs[0] = new MultiSigInput(inputObj, [public1, public2, public3], 2);
+
+    transaction.inputs[0].signatures[0].publicKey.should.deep.equal(public1);
+    should.equal(transaction.inputs[0].signatures[1], undefined);
+    transaction.inputs[0].signatures[2].publicKey.should.deep.equal(public3);
+    transaction.inputs[0]
+      .isValidSignature(transaction, transaction.inputs[0].signatures[0])
+      .should.equal(true);
+    transaction.inputs[0]
+      .isValidSignature(transaction, transaction.inputs[0].signatures[2])
+      .should.equal(true);
+  });
+});

package/test/transaction/input/publickey.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var opcat = require('../../..');
+var Transaction = opcat.Transaction;
+var PrivateKey = opcat.PrivateKey;
+
+describe('PublicKeyInput', function () {
+  var utxo = {
+    txid: '7f3b688cb224ed83e12d9454145c26ac913687086a0a62f2ae0bc10934a4030f',
+    vout: 0,
+    address: 'n4McBrSkw42eYGX5YMACGpkGUJKL3jVSbo',
+    scriptPubKey: '2103c9594cb2ebfebcb0cfd29eacd40ba012606a197beef76f0269ed8c101e56ceddac',
+    amount: 50,
+    confirmations: 104,
+    spendable: true,
+  };
+  var privateKey = PrivateKey.fromWIF('cQ7tSSQDEwaxg9usnnP1Aztqvm9nCQVfNWz9kU2rdocDjknF2vd6');
+  var address = privateKey.toAddress();
+  utxo.address.should.equal(address.toString());
+
+  var destKey = new PrivateKey();
+
+  it('will correctly sign a publickey out transaction', function () {
+    var tx = new Transaction();
+    tx.from(utxo);
+    tx.to(destKey.toAddress(), 10000);
+    tx.sign(privateKey);
+    tx.inputs[0].script.toBuffer().length.should.be.above(0);
+  });
+
+  it('count can count missing signatures', function () {
+    var tx = new Transaction();
+    tx.from(utxo);
+    tx.to(destKey.toAddress(), 10000);
+    var input = tx.inputs[0];
+    input.isFullySigned().should.equal(false);
+    tx.sign(privateKey);
+    input.isFullySigned().should.equal(true);
+  });
+
+  it("it's size can be estimated", function () {
+    var tx = new Transaction();
+    tx.from(utxo);
+    tx.to(destKey.toAddress(), 10000);
+    var input = tx.inputs[0];
+    input._estimateSize().should.equal(114);
+  });
+
+  it("it's signature can be removed", function () {
+    var tx = new Transaction();
+    tx.from(utxo);
+    tx.to(destKey.toAddress(), 10000);
+    var input = tx.inputs[0];
+    tx.sign(privateKey);
+    input.isFullySigned().should.equal(true);
+    input.clearSignatures();
+    input.isFullySigned().should.equal(false);
+  });
+
+  it('returns an empty array if private key mismatches', function () {
+    var tx = new Transaction();
+    tx.from(utxo);
+    tx.to(destKey.toAddress(), 10000);
+    var input = tx.inputs[0];
+    var signatures = input.getSignatures(tx, new PrivateKey(), 0);
+    signatures.length.should.equal(0);
+  });
+});

package/test/transaction/input/publickeyhash.js

@@ -0,0 +1,51 @@
+'use strict';
+
+require('chai').should();
+
+var opcat = require('../../..');
+var Transaction = opcat.Transaction;
+var PrivateKey = opcat.PrivateKey;
+var Address = opcat.Address;
+var Script = opcat.Script;
+var Networks = opcat.Networks;
+
+describe('PublicKeyHashInput', function () {
+  var privateKey = new PrivateKey('KwF9LjRraetZuEjR8VqEq539z137LW5anYDUnVK11vM3mNMHTWb4');
+  var publicKey = privateKey.publicKey;
+  var address = new Address(publicKey, Networks.livenet);
+
+  var output = {
+    address: address.toString(),
+    txId: '66e64ef8a3b384164b78453fa8c8194de9a473ba14f89485a0e433699daec140',
+    outputIndex: 0,
+    script: new Script(address),
+    satoshis: 1000000,
+  };
+  it('can count missing signatures', function () {
+    var transaction = new Transaction().from(output).to(address, 1000000);
+    var input = transaction.inputs[0];
+
+    input.isFullySigned().should.equal(false);
+    transaction.sign(privateKey);
+    input.isFullySigned().should.equal(true);
+  });
+  it("it's size can be estimated", function () {
+    var transaction = new Transaction().from(output).to(address, 1000000);
+    var input = transaction.inputs[0];
+    input._estimateSize().should.equal(180);
+  });
+  it("it's signature can be removed", function () {
+    var transaction = new Transaction().from(output).to(address, 1000000);
+    var input = transaction.inputs[0];
+
+    transaction.sign(privateKey);
+    input.clearSignatures();
+    input.isFullySigned().should.equal(false);
+  });
+  it('returns an empty array if private key mismatches', function () {
+    var transaction = new Transaction().from(output).to(address, 1000000);
+    var input = transaction.inputs[0];
+    var signatures = input.getSignatures(transaction, new PrivateKey(), 0);
+    signatures.length.should.equal(0);
+  });
+});

package/test/transaction/output.js

@@ -0,0 +1,185 @@
+'use strict';
+
+var should = require('chai').should();
+
+var opcat = require('../..');
+var BN = opcat.crypto.BN;
+var BufferWriter = opcat.encoding.BufferWriter;
+var BufferReader = opcat.encoding.BufferReader;
+var Output = opcat.Transaction.Output;
+var Script = opcat.Script;
+
+describe('Output', function () {
+  var output = new Output({
+    satoshis: 0,
+    script: Script.empty(),
+  });
+
+  it('throws error with unrecognized argument', function () {
+    (function () {
+      new Output(12345);
+    }).should.throw(TypeError);
+  });
+
+  it('can be assigned a satoshi amount in big number', function () {
+    var newOutput = new Output({
+      satoshis: new BN(100),
+      script: Script.empty(),
+    });
+    newOutput.satoshis.should.equal(100);
+  });
+
+  it('can be assigned a satoshi amount with a string', function () {
+    var newOutput = new Output({
+      satoshis: '100',
+      script: Script.empty(),
+    });
+    newOutput.satoshis.should.equal(100);
+  });
+
+  describe('will error if output is not a positive integer', function () {
+    it('-100', function () {
+      (function () {
+        new Output({
+          satoshis: -100,
+          script: Script.empty(),
+        });
+      }).should.throw('Output satoshis is not a natural number');
+    });
+
+    it('1.1', function () {
+      (function () {
+        new Output({
+          satoshis: 1.1,
+          script: Script.empty(),
+        });
+      }).should.throw('Output satoshis is not a natural number');
+    });
+
+    it('NaN', function () {
+      (function () {
+        new Output({
+          satoshis: NaN,
+          script: Script.empty(),
+        });
+      }).should.throw('Output satoshis is not a natural number');
+    });
+
+    it('Infinity', function () {
+      (function () {
+        new Output({
+          satoshis: Infinity,
+          script: Script.empty(),
+        });
+      }).should.throw('Output satoshis is not a natural number');
+    });
+  });
+
+  var expectEqualOutputs = function (a, b) {
+    a.satoshis.should.equal(b.satoshis);
+    a.script.toString().should.equal(b.script.toString());
+    a.data.toString().should.equal(b.data.toString());
+  };
+
+  it('deserializes correctly a simple output', function () {
+    var writer = new BufferWriter();
+    output.toBufferWriter(false, writer);
+    var deserialized = Output.fromBufferReader(new BufferReader(writer.toBuffer()));
+    expectEqualOutputs(output, deserialized);
+  });
+
+  it('can instantiate from an object', function () {
+    var out = new Output(output.toObject());
+    should.exist(out);
+  });
+
+  it('can set a script from a buffer', function () {
+    var newOutput = new Output(output.toObject());
+    newOutput.setScript(Script().add(0).toBuffer());
+    newOutput.inspect().should.equal('<Output (0 sats) <Script: OP_0>>');
+  });
+
+  it('has a inspect property', function () {
+    output.inspect().should.equal('<Output (0 sats) <Script: >>');
+  });
+
+  var output2 = new Output({
+    satoshis: 1100000000,
+    script: new Script(
+      'OP_2 33 0x038282263212c609d9ea2a6e3e172de238d8c39' +
+        'cabd5ac1ca10646e23fd5f51508 33 0x038282263212c609d9ea2a6e3e172de23' +
+        '8d8c39cabd5ac1ca10646e23fd5f51508 OP_2 OP_CHECKMULTISIG OP_EQUAL',
+    ),
+  });
+
+  it('toBufferWriter', function () {
+    output2
+      .toBufferWriter(false)
+      .toBuffer()
+      .toString('hex')
+      .should.equal(
+        '00ab904100000000485221038282263212c609d9ea2a6e3e172de2' +
+          '38d8c39cabd5ac1ca10646e23fd5f5150821038282263212c609d9ea2a6e3e172d' +
+          'e238d8c39cabd5ac1ca10646e23fd5f5150852ae8700',
+      );
+  });
+
+  it('roundtrips to/from object', function () {
+    var newOutput = new Output({
+      satoshis: 50,
+      script: new Script().add(0),
+    });
+    var otherOutput = new Output(newOutput.toObject());
+    expectEqualOutputs(newOutput, otherOutput);
+  });
+
+  it('toObject will handle an invalid (null) script', function () {
+    // block 000000000000000b7e48f88e86ceee3e97b4df7c139f5411d14735c1b3c36791 (livenet)
+    // transaction index 2
+    // txid ebc9fa1196a59e192352d76c0f6e73167046b9d37b8302b6bb6968dfd279b767
+    var transaction = opcat.Transaction();
+    transaction.fromString(
+      '01000000019ac03d5ae6a875d970128ef9086cef276a1919684a6988023cc7254691d97e6d010000006b4830450221009d41dc793ba24e65f571473d40b299b6459087cea1509f0d381740b1ac863cb6022039c425906fcaf51b2b84d8092569fb3213de43abaff2180e2a799d4fcb4dd0aa012102d5ede09a8ae667d0f855ef90325e27f6ce35bbe60a1e6e87af7f5b3c652140fdffffffff0801000000000000000101000100000000000000020201000100000000000000014c000100000000000000034c0201000100000000000000014d000100000000000000044dffff01000100000000000000014e000100000000000000064effffffff010000000000',
+    );
+    var obj = transaction.toObject();
+    obj.outputs[2].script.should.equal('4c');
+    obj.outputs[4].script.should.equal('4d');
+    obj.outputs[6].script.should.equal('4e');
+  });
+
+  it('#toObject roundtrip will handle an invalid (null) script', function () {
+    var invalidOutputScript = Buffer.from('0100000000000000014c00', 'hex');
+    var br = new opcat.encoding.BufferReader(invalidOutputScript);
+    var output = Output.fromBufferReader(br);
+    var output2 = new Output(output.toObject());
+    should.equal(output2.script.toString('hex'), output.script.toString('hex'));
+    should.equal(output2.script.toHex(), '4c');
+    should.equal(output2.data.toString('hex'), '');
+  });
+
+  it('inspect will work with an invalid (null) script', function () {
+    var invalidOutputScript = Buffer.from('0100000000000000014c00', 'hex');
+    var br = new opcat.encoding.BufferReader(invalidOutputScript);
+    var output = Output.fromBufferReader(br);
+    output.inspect().should.equal('<Output (1 sats) <Script: OP_PUSHDATA1>>');
+  });
+
+  it('roundtrips to/from JSON', function () {
+    var json = JSON.stringify(output2);
+    var o3 = new Output(JSON.parse(json));
+    JSON.stringify(o3).should.equal(json);
+  });
+
+  it('setScript fails with invalid input', function () {
+    var out = new Output(output2.toJSON());
+    out.setScript.bind(out, 45).should.throw('Invalid argument type: script');
+  });
+
+  it('sets script not null if it is an InvalidBuffer', function () {
+    var output = new Output({
+      satoshis: 1000,
+      script: Buffer.from('4c', 'hex'),
+    });
+    should.equal(output.script.toString(), 'OP_PUSHDATA1');
+  });
+});

package/test/transaction/sighash.js

@@ -0,0 +1,65 @@
+'use strict';
+
+var buffer = require('buffer');
+
+var chai = require('chai');
+chai.should();
+var opcat = require('../../');
+var Script = opcat.Script;
+var BN = opcat.crypto.BN;
+var Transaction = opcat.Transaction;
+var Signature = opcat.crypto.Signature;
+var sighash = Transaction.sighash;
+
+var vectorsSighash = require('../data/sighash.json');
+
+describe('sighash', function () {
+  it('should be able to compute sighash for a coinbase tx', function () {
+    var txhex =
+      '02000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2e039b1e1304c0737c5b68747470733a2f2f6769746875622e636f6d2f62636578742f01000001c096020000000000ffffffff014a355009000000001976a91448b20e254c0677e760bab964aec16818d6b7134a88ac0000000000';
+    var tx = new Transaction(txhex);
+    tx.inputs[0].output = new Transaction.Output({
+      satoshis: 1,
+      script: Script.empty(),
+      data: Buffer.from('')
+    });
+    var sighash = Transaction.Sighash.sighash(tx, Signature.SIGHASH_ALL, 0);
+    sighash
+      .toString('hex')
+      .should.equal('09edc84f4bbf481368554aadb182f2944808cc26f294cbb67679641d135fc41c');
+  });
+
+  var zeroBN = BN.Zero;
+  vectorsSighash.forEach(function (vector, i) {
+    if (i === 0 || !vector[6]) {
+      // First element is just a row describing the next ones
+      return;
+    }
+    it('test vector from bitcoind #' + i + ' (' + vector[6].substring(0, 16) + ')', function () {
+      var txbuf = buffer.Buffer.from(vector[0], 'hex');
+      var satoshis = vector[1];
+      var scriptbuf = buffer.Buffer.from(vector[2], 'hex');
+      var script = Script(scriptbuf);
+      var data = vector[3];
+      var nin = vector[4];
+      var nhashtype = vector[5];
+      // var nhashtype = vector[3]>>>0;
+      var sighashbuf = buffer.Buffer.from(vector[6], 'hex');
+      var tx = new Transaction(txbuf);
+      tx.inputs[0].output = new Transaction.Output({
+        satoshis: satoshis,
+        script: script,
+        data: data
+      });
+
+      // make sure transacion to/from buffer is isomorphic
+      tx.uncheckedSerialize().should.equal(txbuf.toString('hex'));
+
+      // sighash ought to be correct
+      sighash
+        .sighash(tx, nhashtype, nin)
+        .toString('hex')
+        .should.equal(sighashbuf.toString('hex'));
+    });
+  });
+});