@smartledger/bsv 5.5.0 → 5.5.1

package/test/transaction/input/input.js

@@ -0,0 +1,92 @@
+'use strict'
+
+var should = require('chai').should()
+var expect = require('chai').expect
+var _ = require('../../../lib/util/_')
+
+var bsv = require('../../..')
+var errors = bsv.errors
+var PrivateKey = bsv.PrivateKey
+var Address = bsv.Address
+var Script = bsv.Script
+var Networks = bsv.Networks
+var Input = bsv.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('Need a script to create an input')
+    })
+    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,174 @@
+'use strict'
+
+var should = require('chai').should()
+var _ = require('../../../lib/util/_')
+
+var bsv = require('../../..')
+var Transaction = bsv.Transaction
+var PrivateKey = bsv.PrivateKey
+var Address = bsv.Address
+var Script = bsv.Script
+var Signature = bsv.crypto.Signature
+var MultiSigInput = bsv.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 address = new Address('33zbk2aSZYdNbRsMPPt6jgy6Kq1kQreqeb')
+
+  var output = {
+    txId: '66e64ef8a3b384164b78453fa8c8194de9a473ba14f89485a0e433699daec140',
+    outputIndex: 0,
+    script: new Script('5221025c95ec627038e85b5688a9b3d84d28c5ebe66e8c8d697d498e20fe96e3b1ab1d2102cdddfc974d41a62f1f80081deee70592feb7d6e6cf6739d6592edbe7946720e72103c95924e02c240b5545089c69c6432447412b58be43fd671918bd184a5009834353ae'),
+    satoshis: 1000000
+  }
+  it('can count missing signatures', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+
+    input.countSignatures().should.equal(0)
+
+    transaction.sign(privateKey1)
+    input.countSignatures().should.equal(1)
+    input.countMissingSignatures().should.equal(1)
+    input.isFullySigned().should.equal(false)
+
+    transaction.sign(privateKey2)
+    input.countSignatures().should.equal(2)
+    input.countMissingSignatures().should.equal(0)
+    input.isFullySigned().should.equal(true)
+  })
+  it('can count missing signatures, signed with key 3 and 1', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+
+    input.countSignatures().should.equal(0)
+
+    transaction.sign(privateKey3)
+    input.countSignatures().should.equal(1)
+    input.countMissingSignatures().should.equal(1)
+    input.isFullySigned().should.equal(false)
+
+    transaction.sign(privateKey1)
+    input.countSignatures().should.equal(2)
+    input.countMissingSignatures().should.equal(0)
+    input.isFullySigned().should.equal(true)
+  })
+  it('returns a list of public keys with missing signatures', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+
+    _.every(input.publicKeysWithoutSignature(), function (publicKeyMissing) {
+      var serialized = publicKeyMissing.toString()
+      return serialized === public1.toString() ||
+              serialized === public2.toString() ||
+              serialized === public3.toString()
+    }).should.equal(true)
+    transaction.sign(privateKey1)
+    _.every(input.publicKeysWithoutSignature(), function (publicKeyMissing) {
+      var serialized = publicKeyMissing.toString()
+      return serialized === public2.toString() ||
+              serialized === public3.toString()
+    }).should.equal(true)
+  })
+  it('can clear all signatures', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+      .sign(privateKey1)
+      .sign(privateKey2)
+
+    var input = transaction.inputs[0]
+    input.isFullySigned().should.equal(true)
+    input.clearSignatures()
+    input.isFullySigned().should.equal(false)
+  })
+  it('can estimate how heavy is the output going to be', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+    input._estimateSize().should.equal(188)
+  })
+  it('uses SIGHASH_ALL|FORKID by default', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+    var sigs = input.getSignatures(transaction, privateKey1, 0)
+    sigs[0].sigtype.should.equal(Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID)
+  })
+  it('roundtrips to/from object', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+      .sign(privateKey1)
+    var input = transaction.inputs[0]
+    var roundtrip = new MultiSigInput(input.toObject())
+    roundtrip.toObject().should.deep.equal(input.toObject())
+  })
+  it('roundtrips to/from object when not signed', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+    var roundtrip = new MultiSigInput(input.toObject())
+    roundtrip.toObject().should.deep.equal(input.toObject())
+  })
+  it('can parse list of signature buffers, from TX signed with key 1 and 2', function () {
+    var transaction = new Transaction('010000000140c1ae9d6933e4a08594f814ba73a4e94d19c8a83f45784b1684b3a3f84ee666000000009200473044022012bd2f15e56ab1b63d5ee23e194ed995ad4b81a21bcb8e0d913e5e791c07f7280220278bdb6b54cdc608193c869affe28dc2f700902218122770faff25c56142102b01483045022100e74e9955e042aca36f4f3ad907a0926c5b85e5d9608b0678a78a9cbc0259c7a2022053ff761e5f9a80558db7023e45c4979ac3c19a423f0184fb0596d3da308cc4b501ffffffff0140420f000000000017a91419438da7d16709643be5abd8df62ca4034a489a78700000000')
+
+    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('010000000140c1ae9d6933e4a08594f814ba73a4e94d19c8a83f45784b1684b3a3f84ee666000000009300483045022100fc39ce4f51b2766ec8e978296e0594ea4578a3eb2543722fd4053e92bf16e6b1022030f739868397a881b019508b9c725a5c69a3652cb8928027748e93e67dfaef5501483045022100e74e9955e042aca36f4f3ad907a0926c5b85e5d9608b0678a78a9cbc0259c7a2022053ff761e5f9a80558db7023e45c4979ac3c19a423f0184fb0596d3da308cc4b501ffffffff0140420f000000000017a91419438da7d16709643be5abd8df62ca4034a489a78700000000')
+
+    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/multisigscripthash.js

@@ -0,0 +1,111 @@
+'use strict'
+
+require('chai').should()
+var _ = require('../../../lib/util/_')
+
+var bsv = require('../../..')
+var Transaction = bsv.Transaction
+var PrivateKey = bsv.PrivateKey
+var Address = bsv.Address
+var Script = bsv.Script
+var Signature = bsv.crypto.Signature
+var MultiSigScriptHashInput = bsv.Transaction.Input.MultiSigScriptHash
+
+describe('MultiSigScriptHashInput', 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 address = new Address('33zbk2aSZYdNbRsMPPt6jgy6Kq1kQreqeb')
+
+  var output = {
+    address: '33zbk2aSZYdNbRsMPPt6jgy6Kq1kQreqeb',
+    txId: '66e64ef8a3b384164b78453fa8c8194de9a473ba14f89485a0e433699daec140',
+    outputIndex: 0,
+    script: new Script(address),
+    satoshis: 1000000
+  }
+  it('can count missing signatures', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+
+    input.countSignatures().should.equal(0)
+
+    transaction.sign(privateKey1)
+    input.countSignatures().should.equal(1)
+    input.countMissingSignatures().should.equal(1)
+    input.isFullySigned().should.equal(false)
+
+    transaction.sign(privateKey2)
+    input.countSignatures().should.equal(2)
+    input.countMissingSignatures().should.equal(0)
+    input.isFullySigned().should.equal(true)
+  })
+  it('returns a list of public keys with missing signatures', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+
+    _.every(input.publicKeysWithoutSignature(), function (publicKeyMissing) {
+      var serialized = publicKeyMissing.toString()
+      return serialized === public1.toString() ||
+              serialized === public2.toString() ||
+              serialized === public3.toString()
+    }).should.equal(true)
+    transaction.sign(privateKey1)
+    _.every(input.publicKeysWithoutSignature(), function (publicKeyMissing) {
+      var serialized = publicKeyMissing.toString()
+      return serialized === public2.toString() ||
+              serialized === public3.toString()
+    }).should.equal(true)
+  })
+  it('can clear all signatures', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+      .sign(privateKey1)
+      .sign(privateKey2)
+
+    var input = transaction.inputs[0]
+    input.isFullySigned().should.equal(true)
+    input.clearSignatures()
+    input.isFullySigned().should.equal(false)
+  })
+  it('can estimate how heavy is the output going to be', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+    input._estimateSize().should.equal(297)
+  })
+  it('uses SIGHASH_ALL|FORKID by default', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+    var sigs = input.getSignatures(transaction, privateKey1, 0)
+    sigs[0].sigtype.should.equal(Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID)
+  })
+  it('roundtrips to/from object', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+      .sign(privateKey1)
+    var input = transaction.inputs[0]
+    var roundtrip = new MultiSigScriptHashInput(input.toObject())
+    roundtrip.toObject().should.deep.equal(input.toObject())
+  })
+  it('roundtrips to/from object when not signed', function () {
+    var transaction = new Transaction()
+      .from(output, [public1, public2, public3], 2)
+      .to(address, 1000000)
+    var input = transaction.inputs[0]
+    var roundtrip = new MultiSigScriptHashInput(input.toObject())
+    roundtrip.toObject().should.deep.equal(input.toObject())
+  })
+})

package/test/transaction/input/publickey.js

@@ -0,0 +1,68 @@
+'use strict'
+
+var bsv = require('../../..')
+var Transaction = bsv.Transaction
+var PrivateKey = bsv.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,59 @@
+'use strict'
+
+require('chai').should()
+
+var bsv = require('../../..')
+var Transaction = bsv.Transaction
+var PrivateKey = bsv.PrivateKey
+var Address = bsv.Address
+var Script = bsv.Script
+var Networks = bsv.Networks
+
+describe('PublicKeyHashInput', function () {
+  var privateKey = new PrivateKey('KwF9LjRraetZuEjR8VqEq539z137LW5anYDUnVK11vM3mNMHTWb4')
+  var publicKey = privateKey.publicKey
+  var address = new Address(publicKey, Networks.livenet)
+
+  var output = {
+    address: '33zbk2aSZYdNbRsMPPt6jgy6Kq1kQreqeb',
+    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(148)
+  })
+  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 bsv = require('../..')
+var BN = bsv.crypto.BN
+var BufferWriter = bsv.encoding.BufferWriter
+var BufferReader = bsv.encoding.BufferReader
+var Output = bsv.Transaction.Output
+var Script = bsv.Script
+
+describe('Output', function () {
+  var output = new Output({
+    satoshis: 0,
+    script: Script.empty()
+  })
+
+  it('throws error with unrecognized argument', function () {
+    (function () {
+      new Output(12345) //eslint-disable-line
+    }.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({ //eslint-disable-line
+          satoshis: -100,
+          script: Script.empty()
+        })
+      }.should.throw('Output satoshis is not a natural number'))
+    })
+
+    it('1.1', function () {
+      (function () {
+        new Output({ //eslint-disable-line
+          satoshis: 1.1,
+          script: Script.empty()
+        })
+      }.should.throw('Output satoshis is not a natural number'))
+    })
+
+    it('NaN', function () {
+      (function () {
+        new Output({ //eslint-disable-line
+          satoshis: NaN,
+          script: Script.empty()
+        })
+      }.should.throw('Output satoshis is not a natural number'))
+    })
+
+    it('Infinity', function () {
+      (function () {
+        new Output({ //eslint-disable-line
+          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())
+  }
+
+  it('deserializes correctly a simple output', function () {
+    var writer = new BufferWriter()
+    output.toBufferWriter(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 21 0x038282263212c609d9ea2a6e3e172de238d8c39' +
+        'cabd5ac1ca10646e23fd5f51508 21 0x038282263212c609d9ea2a6e3e172de23' +
+        '8d8c39cabd5ac1ca10646e23fd5f51508 OP_2 OP_CHECKMULTISIG OP_EQUAL'
+    )
+  })
+
+  it('toBufferWriter', function () {
+    output2
+      .toBufferWriter()
+      .toBuffer()
+      .toString('hex')
+      .should.equal(
+        '00ab904100000000485215038282263212c609d9ea2a6e3e172de2' +
+          '38d8c39cabd5ac1ca10646e23fd5f5150815038282263212c609d9ea2a6e3e172d' +
+          'e238d8c39cabd5ac1ca10646e23fd5f5150852ae87'
+      )
+  })
+
+  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 = bsv.Transaction()
+    transaction.fromString(
+      '01000000019ac03d5ae6a875d970128ef9086cef276a1919684a6988023cc7254691d97e6d010000006b4830450221009d41dc793ba24e65f571473d40b299b6459087cea1509f0d381740b1ac863cb6022039c425906fcaf51b2b84d8092569fb3213de43abaff2180e2a799d4fcb4dd0aa012102d5ede09a8ae667d0f855ef90325e27f6ce35bbe60a1e6e87af7f5b3c652140fdffffffff080100000000000000010101000000000000000202010100000000000000014c0100000000000000034c02010100000000000000014d0100000000000000044dffff010100000000000000014e0100000000000000064effffffff0100000000'
+    )
+    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('0100000000000000014c', 'hex')
+    var br = new bsv.encoding.BufferReader(invalidOutputScript)
+    var output = Output.fromBufferReader(br)
+    var output2 = new Output(output.toObject())
+    should.equal(output2.script, null)
+    should.equal(output2._scriptBuffer.toString('hex'), '4c')
+  })
+
+  it('inspect will work with an invalid (null) script', function () {
+    var invalidOutputScript = Buffer.from('0100000000000000014c', 'hex')
+    var br = new bsv.encoding.BufferReader(invalidOutputScript)
+    var output = Output.fromBufferReader(br)
+    output.inspect().should.equal('<Output (1 sats) 4c>')
+  })
+
+  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 to null if it is an InvalidBuffer', function () {
+    var output = new Output({
+      satoshis: 1000,
+      script: Buffer.from('4c', 'hex')
+    })
+    should.equal(output.script, null)
+  })
+})