smartledger-bsv 3.0.0

package/lib/transaction/index.js

@@ -0,0 +1,7 @@
+module.exports = require('./transaction')
+
+module.exports.Input = require('./input')
+module.exports.Output = require('./output')
+module.exports.UnspentOutput = require('./unspentoutput')
+module.exports.Signature = require('./signature')
+module.exports.Sighash = require('./sighash')

package/lib/transaction/input/index.js

@@ -0,0 +1,6 @@
+module.exports = require('./input')
+
+module.exports.PublicKey = require('./publickey')
+module.exports.PublicKeyHash = require('./publickeyhash')
+module.exports.MultiSig = require('./multisig.js')
+module.exports.MultiSigScriptHash = require('./multisigscripthash.js')

package/lib/transaction/input/input.js

@@ -0,0 +1,202 @@
+'use strict'
+
+var _ = require('../../util/_')
+var $ = require('../../util/preconditions')
+var errors = require('../../errors')
+var BufferWriter = require('../../encoding/bufferwriter')
+var buffer = require('buffer')
+var JSUtil = require('../../util/js')
+var Script = require('../../script')
+var Sighash = require('../sighash')
+var Output = require('../output')
+
+var MAXINT = 0xffffffff // Math.pow(2, 32) - 1;
+var DEFAULT_RBF_SEQNUMBER = MAXINT - 2
+var DEFAULT_SEQNUMBER = MAXINT
+var DEFAULT_LOCKTIME_SEQNUMBER = MAXINT - 1
+
+function Input (params) {
+  if (!(this instanceof Input)) {
+    return new Input(params)
+  }
+  if (params) {
+    return this._fromObject(params)
+  }
+}
+
+Input.MAXINT = MAXINT
+Input.DEFAULT_SEQNUMBER = DEFAULT_SEQNUMBER
+Input.DEFAULT_LOCKTIME_SEQNUMBER = DEFAULT_LOCKTIME_SEQNUMBER
+Input.DEFAULT_RBF_SEQNUMBER = DEFAULT_RBF_SEQNUMBER
+// txid + output index + sequence number
+Input.BASE_SIZE = 32 + 4 + 4
+
+Object.defineProperty(Input.prototype, 'script', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    if (this.isNull()) {
+      return null
+    }
+    if (!this._script) {
+      this._script = new Script(this._scriptBuffer)
+      this._script._isInput = true
+    }
+    return this._script
+  }
+})
+
+Input.fromObject = function (obj) {
+  $.checkArgument(_.isObject(obj))
+  var input = new Input()
+  return input._fromObject(obj)
+}
+
+Input.prototype._fromObject = function (params) {
+  var prevTxId
+  if (_.isString(params.prevTxId) && JSUtil.isHexa(params.prevTxId)) {
+    prevTxId = buffer.Buffer.from(params.prevTxId, 'hex')
+  } else {
+    prevTxId = params.prevTxId
+  }
+  this.output = params.output
+    ? (params.output instanceof Output ? params.output : new Output(params.output)) : undefined
+  this.prevTxId = prevTxId || params.txidbuf
+  this.outputIndex = _.isUndefined(params.outputIndex) ? params.txoutnum : params.outputIndex
+  this.sequenceNumber = _.isUndefined(params.sequenceNumber)
+    ? (_.isUndefined(params.seqnum) ? DEFAULT_SEQNUMBER : params.seqnum) : params.sequenceNumber
+  if (_.isUndefined(params.script) && _.isUndefined(params.scriptBuffer)) {
+    throw new errors.Transaction.Input.MissingScript()
+  }
+  this.setScript(params.scriptBuffer || params.script)
+  return this
+}
+
+Input.prototype.toObject = Input.prototype.toJSON = function toObject () {
+  var obj = {
+    prevTxId: this.prevTxId.toString('hex'),
+    outputIndex: this.outputIndex,
+    sequenceNumber: this.sequenceNumber,
+    script: this._scriptBuffer.toString('hex')
+  }
+  // add human readable form if input contains valid script
+  if (this.script) {
+    obj.scriptString = this.script.toString()
+  }
+  if (this.output) {
+    obj.output = this.output.toObject()
+  }
+  return obj
+}
+
+Input.fromBufferReader = function (br) {
+  var input = new Input()
+  input.prevTxId = br.readReverse(32)
+  input.outputIndex = br.readUInt32LE()
+  input._scriptBuffer = br.readVarLengthBuffer()
+  input.sequenceNumber = br.readUInt32LE()
+  // TODO: return different classes according to which input it is
+  // e.g: CoinbaseInput, PublicKeyHashInput, MultiSigScriptHashInput, etc.
+  return input
+}
+
+Input.prototype.toBufferWriter = function (writer) {
+  if (!writer) {
+    writer = new BufferWriter()
+  }
+  writer.writeReverse(this.prevTxId)
+  writer.writeUInt32LE(this.outputIndex)
+  var script = this._scriptBuffer
+  writer.writeVarintNum(script.length)
+  writer.write(script)
+  writer.writeUInt32LE(this.sequenceNumber)
+  return writer
+}
+
+Input.prototype.setScript = function (script) {
+  this._script = null
+  if (script instanceof Script) {
+    this._script = script
+    this._script._isInput = true
+    this._scriptBuffer = script.toBuffer()
+  } else if (script === null) {
+    this._script = Script.empty()
+    this._script._isInput = true
+    this._scriptBuffer = this._script.toBuffer()
+  } else if (JSUtil.isHexa(script)) {
+    // hex string script
+    this._scriptBuffer = buffer.Buffer.from(script, 'hex')
+  } else if (_.isString(script)) {
+    // human readable string script
+    this._script = new Script(script)
+    this._script._isInput = true
+    this._scriptBuffer = this._script.toBuffer()
+  } else if (Buffer.isBuffer(script)) {
+    // buffer script
+    this._scriptBuffer = buffer.Buffer.from(script)
+  } else {
+    throw new TypeError('Invalid argument type: script')
+  }
+  return this
+}
+
+/**
+ * Retrieve signatures for the provided PrivateKey.
+ *
+ * @param {Transaction} transaction - the transaction to be signed
+ * @param {PrivateKey} privateKey - the private key to use when signing
+ * @param {number} inputIndex - the index of this input in the provided transaction
+ * @param {number} sigType - defaults to Signature.SIGHASH_ALL
+ * @param {Buffer} addressHash - if provided, don't calculate the hash of the
+ *     public key associated with the private key provided
+ * @abstract
+ */
+Input.prototype.getSignatures = function () {
+  throw new errors.AbstractMethodInvoked(
+    'Trying to sign unsupported output type (only P2PKH and P2SH multisig inputs are supported)' +
+    ' for input: ' + JSON.stringify(this)
+  )
+}
+
+Input.prototype.isFullySigned = function () {
+  throw new errors.AbstractMethodInvoked('Input#isFullySigned')
+}
+
+Input.prototype.isFinal = function () {
+  return this.sequenceNumber === Input.MAXINT
+}
+
+Input.prototype.addSignature = function () {
+  throw new errors.AbstractMethodInvoked('Input#addSignature')
+}
+
+Input.prototype.clearSignatures = function () {
+  throw new errors.AbstractMethodInvoked('Input#clearSignatures')
+}
+
+Input.prototype.isValidSignature = function (transaction, signature) {
+  // FIXME: Refactor signature so this is not necessary
+  signature.signature.nhashtype = signature.sigtype
+  return Sighash.verify(
+    transaction,
+    signature.signature,
+    signature.publicKey,
+    signature.inputIndex,
+    this.output.script,
+    this.output.satoshisBN
+  )
+}
+
+/**
+ * @returns true if this is a coinbase input (represents no input)
+ */
+Input.prototype.isNull = function () {
+  return this.prevTxId.toString('hex') === '0000000000000000000000000000000000000000000000000000000000000000' &&
+    this.outputIndex === 0xffffffff
+}
+
+Input.prototype._estimateSize = function () {
+  return this.toBufferWriter().toBuffer().length
+}
+
+module.exports = Input

package/lib/transaction/input/multisig.js

@@ -0,0 +1,220 @@
+'use strict'
+
+var _ = require('../../util/_')
+var inherits = require('inherits')
+var Input = require('./input')
+var Output = require('../output')
+var $ = require('../../util/preconditions')
+
+var Script = require('../../script')
+var Signature = require('../../crypto/signature')
+var Sighash = require('../sighash')
+var TransactionSignature = require('../signature')
+var PublicKey = require('../../publickey')
+var Varint = require('../../encoding/varint')
+
+/**
+ * @constructor
+ */
+function MultiSigInput (input, pubkeys, threshold, signatures) {
+  Input.apply(this, arguments)
+  var self = this
+  pubkeys = pubkeys || input.publicKeys
+  threshold = threshold || input.threshold
+  signatures = signatures || input.signatures
+  this.publicKeys = pubkeys.map(k => k.toString('hex')).sort().map(k => new PublicKey(k))
+  $.checkState(Script.buildMultisigOut(this.publicKeys, threshold).equals(this.output.script),
+    'Provided public keys don\'t match to the provided output script')
+  this.publicKeyIndex = {}
+  _.each(this.publicKeys, function (publicKey, index) {
+    self.publicKeyIndex[publicKey.toString()] = index
+  })
+  this.threshold = threshold
+  // Empty array of signatures
+  this.signatures = signatures ? this._deserializeSignatures(signatures) : new Array(this.publicKeys.length)
+}
+inherits(MultiSigInput, Input)
+
+MultiSigInput.prototype.toObject = function () {
+  var obj = Input.prototype.toObject.apply(this, arguments)
+  obj.threshold = this.threshold
+  obj.publicKeys = _.map(this.publicKeys, function (publicKey) { return publicKey.toString() })
+  obj.signatures = this._serializeSignatures()
+  return obj
+}
+
+MultiSigInput.prototype._deserializeSignatures = function (signatures) {
+  return _.map(signatures, function (signature) {
+    if (!signature) {
+      return undefined
+    }
+    return new TransactionSignature(signature)
+  })
+}
+
+MultiSigInput.prototype._serializeSignatures = function () {
+  return _.map(this.signatures, function (signature) {
+    if (!signature) {
+      return undefined
+    }
+    return signature.toObject()
+  })
+}
+
+MultiSigInput.prototype.getSignatures = function (transaction, privateKey, index, sigtype) {
+  $.checkState(this.output instanceof Output)
+  sigtype = sigtype || (Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID)
+
+  var self = this
+  var results = []
+  _.each(this.publicKeys, function (publicKey) {
+    if (publicKey.toString() === privateKey.publicKey.toString()) {
+      results.push(new TransactionSignature({
+        publicKey: privateKey.publicKey,
+        prevTxId: self.prevTxId,
+        outputIndex: self.outputIndex,
+        inputIndex: index,
+        signature: Sighash.sign(transaction, privateKey, sigtype, index, self.output.script, self.output.satoshisBN),
+        sigtype: sigtype
+      }))
+    }
+  })
+
+  return results
+}
+
+MultiSigInput.prototype.addSignature = function (transaction, signature) {
+  $.checkState(!this.isFullySigned(), 'All needed signatures have already been added')
+  $.checkArgument(!_.isUndefined(this.publicKeyIndex[signature.publicKey.toString()]),
+    'Signature has no matching public key')
+  $.checkState(this.isValidSignature(transaction, signature))
+  this.signatures[this.publicKeyIndex[signature.publicKey.toString()]] = signature
+  this._updateScript()
+  return this
+}
+
+MultiSigInput.prototype._updateScript = function () {
+  this.setScript(Script.buildMultisigIn(
+    this.publicKeys,
+    this.threshold,
+    this._createSignatures()
+  ))
+  return this
+}
+
+MultiSigInput.prototype._createSignatures = function () {
+  return _.map(
+    _.filter(this.signatures, function (signature) { return !_.isUndefined(signature) }),
+    function (signature) {
+      return Buffer.concat([
+        signature.signature.toDER(),
+        Buffer.from([signature.sigtype & 0xff])
+      ])
+    }
+  )
+}
+
+MultiSigInput.prototype.clearSignatures = function () {
+  this.signatures = new Array(this.publicKeys.length)
+  this._updateScript()
+}
+
+MultiSigInput.prototype.isFullySigned = function () {
+  return this.countSignatures() === this.threshold
+}
+
+MultiSigInput.prototype.countMissingSignatures = function () {
+  return this.threshold - this.countSignatures()
+}
+
+MultiSigInput.prototype.countSignatures = function () {
+  return _.reduce(this.signatures, function (sum, signature) {
+    return sum + (!!signature)
+  }, 0)
+}
+
+MultiSigInput.prototype.publicKeysWithoutSignature = function () {
+  var self = this
+  return _.filter(this.publicKeys, function (publicKey) {
+    return !(self.signatures[self.publicKeyIndex[publicKey.toString()]])
+  })
+}
+
+MultiSigInput.prototype.isValidSignature = function (transaction, signature) {
+  // FIXME: Refactor signature so this is not necessary
+  signature.signature.nhashtype = signature.sigtype
+  return Sighash.verify(
+    transaction,
+    signature.signature,
+    signature.publicKey,
+    signature.inputIndex,
+    this.output.script,
+    this.output.satoshisBN
+  )
+}
+
+/**
+ *
+ * @param {Buffer[]} signatures
+ * @param {PublicKey[]} publicKeys
+ * @param {Transaction} transaction
+ * @param {Integer} inputIndex
+ * @param {Input} input
+ * @returns {TransactionSignature[]}
+ */
+MultiSigInput.normalizeSignatures = function (transaction, input, inputIndex, signatures, publicKeys) {
+  return publicKeys.map(function (pubKey) {
+    var signatureMatch = null
+    signatures = signatures.filter(function (signatureBuffer) {
+      if (signatureMatch) {
+        return true
+      }
+
+      var signature = new TransactionSignature({
+        signature: Signature.fromTxFormat(signatureBuffer),
+        publicKey: pubKey,
+        prevTxId: input.prevTxId,
+        outputIndex: input.outputIndex,
+        inputIndex: inputIndex,
+        sigtype: Signature.SIGHASH_ALL
+      })
+
+      signature.signature.nhashtype = signature.sigtype
+      var isMatch = Sighash.verify(
+        transaction,
+        signature.signature,
+        signature.publicKey,
+        signature.inputIndex,
+        input.output.script
+      )
+
+      if (isMatch) {
+        signatureMatch = signature
+        return false
+      }
+
+      return true
+    })
+
+    return signatureMatch || null
+  })
+}
+
+// 32   txid
+// 4    output index
+// --- script ---
+// ??? script size (VARINT)
+// 1    OP_0
+// --- signature list ---
+//      1       signature size (OP_PUSHDATA)
+//      <=72    signature (DER + SIGHASH type)
+//
+// 4    sequence number
+MultiSigInput.SIGNATURE_SIZE = 73
+
+MultiSigInput.prototype._estimateSize = function () {
+  var scriptSize = 1 + this.threshold * MultiSigInput.SIGNATURE_SIZE
+  return Input.BASE_SIZE + Varint(scriptSize).toBuffer().length + scriptSize
+}
+
+module.exports = MultiSigInput

package/lib/transaction/input/multisigscripthash.js

@@ -0,0 +1,189 @@
+'use strict'
+
+var _ = require('../../util/_')
+var inherits = require('inherits')
+var Input = require('./input')
+var Output = require('../output')
+var $ = require('../../util/preconditions')
+
+var Script = require('../../script')
+var Signature = require('../../crypto/signature')
+var Sighash = require('../sighash')
+var TransactionSignature = require('../signature')
+var PublicKey = require('../../publickey')
+var Varint = require('../../encoding/varint')
+
+/**
+ * @constructor
+ */
+function MultiSigScriptHashInput (input, pubkeys, threshold, signatures) {
+  Input.apply(this, arguments)
+  var self = this
+  pubkeys = pubkeys || input.publicKeys
+  threshold = threshold || input.threshold
+  signatures = signatures || input.signatures
+  this.publicKeys = pubkeys.map(k => k.toString('hex')).sort().map(k => new PublicKey(k))
+  this.redeemScript = Script.buildMultisigOut(this.publicKeys, threshold)
+  $.checkState(Script.buildScriptHashOut(this.redeemScript).equals(this.output.script),
+    'Provided public keys don\'t hash to the provided output')
+  this.publicKeyIndex = {}
+  _.each(this.publicKeys, function (publicKey, index) {
+    self.publicKeyIndex[publicKey.toString()] = index
+  })
+  this.threshold = threshold
+  // Empty array of signatures
+  this.signatures = signatures ? this._deserializeSignatures(signatures) : new Array(this.publicKeys.length)
+}
+inherits(MultiSigScriptHashInput, Input)
+
+MultiSigScriptHashInput.prototype.toObject = function () {
+  var obj = Input.prototype.toObject.apply(this, arguments)
+  obj.threshold = this.threshold
+  obj.publicKeys = _.map(this.publicKeys, function (publicKey) { return publicKey.toString() })
+  obj.signatures = this._serializeSignatures()
+  return obj
+}
+
+MultiSigScriptHashInput.prototype._deserializeSignatures = function (signatures) {
+  return _.map(signatures, function (signature) {
+    if (!signature) {
+      return undefined
+    }
+    return new TransactionSignature(signature)
+  })
+}
+
+MultiSigScriptHashInput.prototype._serializeSignatures = function () {
+  return _.map(this.signatures, function (signature) {
+    if (!signature) {
+      return undefined
+    }
+    return signature.toObject()
+  })
+}
+
+MultiSigScriptHashInput.prototype.getSignatures = function (transaction, privateKey, index, sigtype) {
+  $.checkState(this.output instanceof Output)
+  sigtype = sigtype || (Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID)
+
+  var self = this
+  var results = []
+  _.each(this.publicKeys, function (publicKey) {
+    if (publicKey.toString() === privateKey.publicKey.toString()) {
+      results.push(new TransactionSignature({
+        publicKey: privateKey.publicKey,
+        prevTxId: self.prevTxId,
+        outputIndex: self.outputIndex,
+        inputIndex: index,
+        signature: Sighash.sign(transaction, privateKey, sigtype, index, self.redeemScript, self.output.satoshisBN),
+        sigtype: sigtype
+      }))
+    }
+  })
+  return results
+}
+
+MultiSigScriptHashInput.prototype.addSignature = function (transaction, signature) {
+  $.checkState(!this.isFullySigned(), 'All needed signatures have already been added')
+  $.checkArgument(!_.isUndefined(this.publicKeyIndex[signature.publicKey.toString()]),
+    'Signature has no matching public key')
+  $.checkState(this.isValidSignature(transaction, signature))
+  this.signatures[this.publicKeyIndex[signature.publicKey.toString()]] = signature
+  this._updateScript()
+  return this
+}
+
+MultiSigScriptHashInput.prototype._updateScript = function () {
+  this.setScript(Script.buildP2SHMultisigIn(
+    this.publicKeys,
+    this.threshold,
+    this._createSignatures(),
+    { cachedMultisig: this.redeemScript }
+  ))
+  return this
+}
+
+MultiSigScriptHashInput.prototype._createSignatures = function () {
+  return _.map(
+    _.filter(this.signatures, function (signature) { return !_.isUndefined(signature) }),
+    function (signature) {
+      return Buffer.concat([
+        signature.signature.toDER(),
+        Buffer.from([signature.sigtype & 0xff])
+      ])
+    }
+  )
+}
+
+MultiSigScriptHashInput.prototype.clearSignatures = function () {
+  this.signatures = new Array(this.publicKeys.length)
+  this._updateScript()
+}
+
+MultiSigScriptHashInput.prototype.isFullySigned = function () {
+  return this.countSignatures() === this.threshold
+}
+
+MultiSigScriptHashInput.prototype.countMissingSignatures = function () {
+  return this.threshold - this.countSignatures()
+}
+
+MultiSigScriptHashInput.prototype.countSignatures = function () {
+  return _.reduce(this.signatures, function (sum, signature) {
+    return sum + (!!signature)
+  }, 0)
+}
+
+MultiSigScriptHashInput.prototype.publicKeysWithoutSignature = function () {
+  var self = this
+  return _.filter(this.publicKeys, function (publicKey) {
+    return !(self.signatures[self.publicKeyIndex[publicKey.toString()]])
+  })
+}
+
+MultiSigScriptHashInput.prototype.isValidSignature = function (transaction, signature) {
+  // FIXME: Refactor signature so this is not necessary
+  signature.signature.nhashtype = signature.sigtype
+  return Sighash.verify(
+    transaction,
+    signature.signature,
+    signature.publicKey,
+    signature.inputIndex,
+    this.redeemScript,
+    this.output.satoshisBN
+  )
+}
+
+// 32   txid
+// 4    output index
+// --- script ---
+// ???  script size (VARINT)
+// 1    OP_0
+// --- signature list ---
+//      1       signature size (OP_PUSHDATA)
+//      <=72    signature (DER + SIGHASH type)
+//
+// ???  redeem script size (OP_PUSHDATA)
+// --- redeem script ---
+//      1       OP_2
+//      --- public key list ---
+//      1       public key size (OP_PUSHDATA)
+//      33      compressed public key
+//
+//      1       OP_3
+//      1       OP_CHECKMULTISIG
+//
+// 4    sequence number
+MultiSigScriptHashInput.SIGNATURE_SIZE = 73
+MultiSigScriptHashInput.PUBKEY_SIZE = 34
+
+MultiSigScriptHashInput.prototype._estimateSize = function () {
+  var pubKeysSize = this.publicKeys.length * MultiSigScriptHashInput.PUBKEY_SIZE
+  var sigsSize = this.threshold * MultiSigScriptHashInput.SIGNATURE_SIZE
+  var redeemScriptSize = 3 + pubKeysSize
+  var redeemScriptPushdataSize = redeemScriptSize <= 75 ? 1 : redeemScriptSize <= 255 ? 2 : 3
+  var scriptLength = sigsSize + 1 + redeemScriptPushdataSize + redeemScriptSize
+  return Input.BASE_SIZE + Varint(scriptLength).toBuffer().length + scriptLength
+}
+
+module.exports = MultiSigScriptHashInput