@smartledger/bsv 5.5.0 → 5.5.1

package/test/transaction/sighash.js

@@ -0,0 +1,71 @@
+'use strict'
+
+var buffer = require('buffer')
+
+var chai = require('chai')
+chai.should()
+var bsv = require('../../')
+var Script = bsv.Script
+var BN = bsv.crypto.BN
+var Transaction = bsv.Transaction
+var Signature = bsv.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 = '02000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2e039b1e1304c0737c5b68747470733a2f2f6769746875622e636f6d2f62636578742f01000001c096020000000000ffffffff014a355009000000001976a91448b20e254c0677e760bab964aec16818d6b7134a88ac00000000'
+    var tx = new Transaction(txhex)
+    var sighash = Transaction.Sighash.sighash(
+      tx,
+      Signature.SIGHASH_ALL,
+      0,
+      Script.empty()
+    )
+    sighash.toString('hex').should.equal('6829f7d44dfd4654749b8027f44c9381527199f78ae9b0d58ffc03fdab3c82f1')
+  })
+
+  it('Should require amount for sigHash ForkId=0', function () {
+    var vector = ['3eb87070042d16f9469b0080a3c1fe8de0feae345200beef8b1e0d7c62501ae0df899dca1e03000000066a0065525365ffffffffd14a9a335e8babddd89b5d0b6a0f41dd6b18848050a0fc48ce32d892e11817fd030000000863acac00535200527ff62cf3ad30d9064e180eaed5e6303950121a8086b5266b55156e4f7612f2c7ebf223e0020000000100ffffffff6273ca3aceb55931160fa7a3064682b4790ee016b4a5c0c0d101fd449dff88ba01000000055351ac526aa3b8223d0421f25b0400000000026552f92db70500000000075253516a656a53c4a908010000000000b5192901000000000652525251516aa148ca38', 'acab53', 3, -1325231124, 'fbbc83ed610e416d94dcee2bb3bc35dfea8060b8052c59eabd7e998e3e978328']
+    var txbuf = buffer.Buffer.from(vector[0], 'hex')
+    var scriptbuf = buffer.Buffer.from(vector[1], 'hex')
+    var subscript = Script(scriptbuf)
+    var nin = vector[2]
+    var nhashtype = vector[3]
+    var sighashbuf = buffer.Buffer.from(vector[4], 'hex')
+    var tx = new Transaction(txbuf)
+
+    // make sure transacion to/from buffer is isomorphic
+    tx.uncheckedSerialize().should.equal(txbuf.toString('hex'));
+
+    // sighash ought to be correct
+    (function () {
+      sighash.sighash(tx, nhashtype, nin, subscript).toString('hex').should.equal(sighashbuf.toString('hex'))
+    }).should.throw('Invalid Argument')
+  })
+
+  var zeroBN = BN.Zero
+  vectorsSighash.forEach(function (vector, i) {
+    if (i === 0 || !vector[4]) {
+      // First element is just a row describing the next ones
+      return
+    }
+    it('test vector from bitcoind #' + i + ' (' + vector[4].substring(0, 16) + ')', function () {
+      var txbuf = buffer.Buffer.from(vector[0], 'hex')
+      var scriptbuf = buffer.Buffer.from(vector[1], 'hex')
+      var subscript = Script(scriptbuf)
+      var nin = vector[2]
+      var nhashtype = vector[3]
+      // var nhashtype = vector[3]>>>0;
+      var sighashbuf = buffer.Buffer.from(vector[4], 'hex')
+      var tx = new Transaction(txbuf)
+
+      // 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, subscript, zeroBN).toString('hex').should.equal(sighashbuf.toString('hex'))
+    })
+  })
+})

package/test/transaction/signature.js

@@ -0,0 +1,127 @@
+'use strict'
+
+require('chai').should()
+var expect = require('chai').expect
+
+var bsv = require('../..')
+var Transaction = bsv.Transaction
+var TransactionSignature = bsv.Transaction.Signature
+var Script = bsv.Script
+var PrivateKey = bsv.PrivateKey
+var errors = bsv.errors
+
+describe('TransactionSignature', function () {
+  var fromAddress = 'mszYqVnqKoQx4jcTdJXxwKAissE3Jbrrc1'
+  var privateKey = 'cSBnVM4xvxarwGQuAfQFwqDg9k5tErHUHzgWsEfD4zdwUasvqRVY'
+  var simpleUtxoWith100000Satoshis = {
+    address: fromAddress,
+    txId: 'a477af6b2667c29670467e4e0728b685ee07b240235771862318e29ddbe58458',
+    outputIndex: 0,
+    script: Script.buildPublicKeyHashOut(fromAddress).toString(),
+    satoshis: 100000
+  }
+
+  var getSignatureFromTransaction = function () {
+    var transaction = new Transaction()
+    transaction.from(simpleUtxoWith100000Satoshis)
+    return transaction.getSignatures(privateKey)[0]
+  }
+
+  it('can be created without the `new` keyword', function () {
+    var signature = getSignatureFromTransaction()
+    var serialized = signature.toObject()
+    var nonew = TransactionSignature(serialized)
+    expect(nonew.toObject()).to.deep.equal(serialized)
+  })
+
+  it('can be retrieved from Transaction#getSignatures', function () {
+    var signature = getSignatureFromTransaction()
+    expect(signature instanceof TransactionSignature).to.equal(true)
+  })
+
+  it('fails when trying to create from invalid arguments', function () {
+    expect(function () {
+      return new TransactionSignature()
+    }).to.throw(errors.InvalidArgument)
+    expect(function () {
+      return new TransactionSignature(1)
+    }).to.throw(errors.InvalidArgument)
+    expect(function () {
+      return new TransactionSignature('hello world')
+    }).to.throw(errors.InvalidArgument)
+  })
+  it('returns the same object if called with a TransactionSignature', function () {
+    var signature = getSignatureFromTransaction()
+    expect(new TransactionSignature(signature)).to.equal(signature)
+  })
+
+  it('gets returned by a P2SH multisig output', function () {
+    var private1 = new PrivateKey('6ce7e97e317d2af16c33db0b9270ec047a91bff3eff8558afb5014afb2bb5976')
+    var private2 = new PrivateKey('c9b26b0f771a0d2dad88a44de90f05f416b3b385ff1d989343005546a0032890')
+    var public1 = private1.publicKey
+    var public2 = private2.publicKey
+    var utxo = {
+      txId: '0000000000000000000000000000000000000000000000000000000000000000', // Not relevant
+      outputIndex: 0,
+      script: Script.buildMultisigOut([public1, public2], 2).toScriptHashOut(),
+      satoshis: 100000
+    }
+    var transaction = new Transaction().from(utxo, [public1, public2], 2)
+    var signatures = transaction.getSignatures(private1)
+    expect(signatures[0] instanceof TransactionSignature).to.equal(true)
+    signatures = transaction.getSignatures(private2)
+    expect(signatures[0] instanceof TransactionSignature).to.equal(true)
+  })
+
+  it('can be aplied to a Transaction with Transaction#addSignature', function () {
+    var transaction = new Transaction()
+    transaction.from(simpleUtxoWith100000Satoshis)
+    var signature = transaction.getSignatures(privateKey)[0]
+    var addSignature = function () {
+      return transaction.applySignature(signature)
+    }
+    expect(signature instanceof TransactionSignature).to.equal(true)
+    expect(addSignature).to.not.throw()
+  })
+
+  describe('serialization', function () {
+    it('serializes to an object and roundtrips correctly', function () {
+      var signature = getSignatureFromTransaction()
+      var serialized = signature.toObject()
+      expect(new TransactionSignature(serialized).toObject()).to.deep.equal(serialized)
+    })
+
+    it('can be deserialized with fromObject', function () {
+      var signature = getSignatureFromTransaction()
+      var serialized = signature.toObject()
+      expect(TransactionSignature.fromObject(serialized).toObject()).to.deep.equal(serialized)
+    })
+
+    it('can deserialize when signature is a buffer', function () {
+      var signature = getSignatureFromTransaction()
+      var serialized = signature.toObject()
+      serialized.signature = Buffer.from(serialized.signature, 'hex')
+      expect(TransactionSignature.fromObject(serialized).toObject()).to.deep.equal(signature.toObject())
+    })
+
+    it('can roundtrip to/from json', function () {
+      var signature = getSignatureFromTransaction()
+      var serialized = signature.toObject()
+      var json = JSON.stringify(signature)
+      expect(TransactionSignature(JSON.parse(json)).toObject()).to.deep.equal(serialized)
+      expect(TransactionSignature.fromObject(JSON.parse(json)).toObject()).to.deep.equal(serialized)
+    })
+
+    it('can parse a previously known json string', function () {
+      var str = JSON.stringify(TransactionSignature(JSON.parse(testJSON)))
+      expect(JSON.parse(str)).to.deep.equal(JSON.parse(testJSON))
+    })
+
+    it('can deserialize a previously known object', function () {
+      expect(TransactionSignature(testObject).toObject()).to.deep.equal(testObject)
+    })
+  })
+
+  var testJSON = '{"publicKey":"0223078d2942df62c45621d209fab84ea9a7a23346201b7727b9b45a29c4e76f5e","prevTxId":"a477af6b2667c29670467e4e0728b685ee07b240235771862318e29ddbe58458","outputIndex":0,"inputIndex":0,"signature":"3045022100c728eac064154edba15d4f3e6cbd9be6da3498f80a783ab3391f992b4d9d71ca0220729eff4564dc06aa1d80ab73100540fe5ebb6f280b4a87bc32399f861a7b2563","sigtype":1}'
+  var testObject = JSON.parse(testJSON)
+})