smartledger-bsv 3.0.0

package/lib/transaction/input/publickey.js

@@ -0,0 +1,96 @@
+'use strict'
+
+var inherits = require('inherits')
+
+var $ = require('../../util/preconditions')
+
+var Input = require('./input')
+var Output = require('../output')
+var Sighash = require('../sighash')
+var Script = require('../../script')
+var Signature = require('../../crypto/signature')
+var TransactionSignature = require('../signature')
+
+/**
+ * Represents a special kind of input of PayToPublicKey kind.
+ * @constructor
+ */
+function PublicKeyInput () {
+  Input.apply(this, arguments)
+}
+inherits(PublicKeyInput, Input)
+
+/**
+ * @param {Transaction} transaction - the transaction to be signed
+ * @param {PrivateKey} privateKey - the private key with which to sign the transaction
+ * @param {number} index - the index of the input in the transaction input vector
+ * @param {number=} sigtype - the type of signature, defaults to Signature.SIGHASH_ALL
+ * @return {Array} of objects that can be
+ */
+PublicKeyInput.prototype.getSignatures = function (transaction, privateKey, index, sigtype) {
+  $.checkState(this.output instanceof Output)
+  sigtype = sigtype || (Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID)
+  var publicKey = privateKey.toPublicKey()
+  if (publicKey.toString() === this.output.script.getPublicKey().toString('hex')) {
+    return [new TransactionSignature({
+      publicKey: publicKey,
+      prevTxId: this.prevTxId,
+      outputIndex: this.outputIndex,
+      inputIndex: index,
+      signature: Sighash.sign(transaction, privateKey, sigtype, index, this.output.script, this.output.satoshisBN),
+      sigtype: sigtype
+    })]
+  }
+  return []
+}
+
+/**
+ * Add the provided signature
+ *
+ * @param {Object} signature
+ * @param {PublicKey} signature.publicKey
+ * @param {Signature} signature.signature
+ * @param {number=} signature.sigtype
+ * @return {PublicKeyInput} this, for chaining
+ */
+PublicKeyInput.prototype.addSignature = function (transaction, signature) {
+  $.checkState(this.isValidSignature(transaction, signature), 'Signature is invalid')
+  this.setScript(Script.buildPublicKeyIn(
+    signature.signature.toDER(),
+    signature.sigtype
+  ))
+  return this
+}
+
+/**
+ * Clear the input's signature
+ * @return {PublicKeyHashInput} this, for chaining
+ */
+PublicKeyInput.prototype.clearSignatures = function () {
+  this.setScript(Script.empty())
+  return this
+}
+
+/**
+ * Query whether the input is signed
+ * @return {boolean}
+ */
+PublicKeyInput.prototype.isFullySigned = function () {
+  return this.script.isPublicKeyIn()
+}
+
+// 32   txid
+// 4    output index
+// ---
+// 1    script size (VARINT)
+// 1    signature size (OP_PUSHDATA)
+// <=72 signature (DER + SIGHASH type)
+// ---
+// 4    sequence number
+PublicKeyInput.SCRIPT_MAX_SIZE = 74
+
+PublicKeyInput.prototype._estimateSize = function () {
+  return Input.BASE_SIZE + PublicKeyInput.SCRIPT_MAX_SIZE
+}
+
+module.exports = PublicKeyInput

package/lib/transaction/input/publickeyhash.js

@@ -0,0 +1,103 @@
+'use strict'
+
+var inherits = require('inherits')
+
+var $ = require('../../util/preconditions')
+
+var Hash = require('../../crypto/hash')
+var Input = require('./input')
+var Output = require('../output')
+var Sighash = require('../sighash')
+var Script = require('../../script')
+var Signature = require('../../crypto/signature')
+var TransactionSignature = require('../signature')
+
+/**
+ * Represents a special kind of input of PayToPublicKeyHash kind.
+ * @constructor
+ */
+function PublicKeyHashInput () {
+  Input.apply(this, arguments)
+}
+inherits(PublicKeyHashInput, Input)
+
+/**
+ * @param {Transaction} transaction - the transaction to be signed
+ * @param {PrivateKey} privateKey - the private key with which to sign the transaction
+ * @param {number} index - the index of the input in the transaction input vector
+ * @param {number=} sigtype - the type of signature, defaults to Signature.SIGHASH_ALL
+ * @param {Buffer=} hashData - the precalculated hash of the public key associated with the privateKey provided
+ * @return {Array} of objects that can be
+ */
+PublicKeyHashInput.prototype.getSignatures = function (transaction, privateKey, index, sigtype, hashData) {
+  $.checkState(this.output instanceof Output)
+  hashData = hashData || Hash.sha256ripemd160(privateKey.publicKey.toBuffer())
+  sigtype = sigtype || (Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID)
+
+  if (hashData.equals(this.output.script.getPublicKeyHash())) {
+    return [new TransactionSignature({
+      publicKey: privateKey.publicKey,
+      prevTxId: this.prevTxId,
+      outputIndex: this.outputIndex,
+      inputIndex: index,
+      signature: Sighash.sign(transaction, privateKey, sigtype, index, this.output.script, this.output.satoshisBN),
+      sigtype: sigtype
+    })]
+  }
+  return []
+}
+
+/**
+ * Add the provided signature
+ *
+ * @param {Object} signature
+ * @param {PublicKey} signature.publicKey
+ * @param {Signature} signature.signature
+ * @param {number=} signature.sigtype
+ * @return {PublicKeyHashInput} this, for chaining
+ */
+PublicKeyHashInput.prototype.addSignature = function (transaction, signature) {
+  $.checkState(this.isValidSignature(transaction, signature), 'Signature is invalid')
+
+  this.setScript(Script.buildPublicKeyHashIn(
+    signature.publicKey,
+    signature.signature.toDER(),
+    signature.sigtype
+  ))
+  return this
+}
+
+/**
+ * Clear the input's signature
+ * @return {PublicKeyHashInput} this, for chaining
+ */
+PublicKeyHashInput.prototype.clearSignatures = function () {
+  this.setScript(Script.empty())
+  return this
+}
+
+/**
+ * Query whether the input is signed
+ * @return {boolean}
+ */
+PublicKeyHashInput.prototype.isFullySigned = function () {
+  return this.script.isPublicKeyHashIn()
+}
+
+// 32   txid
+// 4    output index
+// --- script ---
+// 1    script size (VARINT)
+// 1    signature size (OP_PUSHDATA)
+// <=72 signature (DER + SIGHASH type)
+// 1    public key size (OP_PUSHDATA)
+// 33   compressed public key
+//
+// 4    sequence number
+PublicKeyHashInput.SCRIPT_MAX_SIZE = 108
+
+PublicKeyHashInput.prototype._estimateSize = function () {
+  return Input.BASE_SIZE + PublicKeyHashInput.SCRIPT_MAX_SIZE
+}
+
+module.exports = PublicKeyHashInput

package/lib/transaction/output.js

@@ -0,0 +1,192 @@
+'use strict'
+
+var _ = require('../util/_')
+var BN = require('../crypto/bn')
+var buffer = require('buffer')
+var JSUtil = require('../util/js')
+var BufferWriter = require('../encoding/bufferwriter')
+var Varint = require('../encoding/varint')
+var Script = require('../script')
+var $ = require('../util/preconditions')
+var errors = require('../errors')
+
+var MAX_SAFE_INTEGER = 0x1fffffffffffff
+
+function Output (args) {
+  if (!(this instanceof Output)) {
+    return new Output(args)
+  }
+  if (_.isObject(args)) {
+    this.satoshis = args.satoshis
+    if (Buffer.isBuffer(args.script)) {
+      this._scriptBuffer = args.script
+    } else {
+      var script
+      if (_.isString(args.script) && JSUtil.isHexa(args.script)) {
+        script = buffer.Buffer.from(args.script, 'hex')
+      } else {
+        script = args.script
+      }
+      this.setScript(script)
+    }
+  } else {
+    throw new TypeError('Unrecognized argument for Output')
+  }
+}
+
+Object.defineProperty(Output.prototype, 'script', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    if (this._script) {
+      return this._script
+    } else {
+      this.setScriptFromBuffer(this._scriptBuffer)
+      return this._script
+    }
+  }
+})
+
+Object.defineProperty(Output.prototype, 'satoshis', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    return this._satoshis
+  },
+  set: function (num) {
+    if (num instanceof BN) {
+      this._satoshisBN = num
+      this._satoshis = num.toNumber()
+    } else if (_.isString(num)) {
+      this._satoshis = parseInt(num)
+      this._satoshisBN = BN.fromNumber(this._satoshis)
+    } else {
+      $.checkArgument(
+        JSUtil.isNaturalNumber(num),
+        'Output satoshis is not a natural number'
+      )
+      this._satoshisBN = BN.fromNumber(num)
+      this._satoshis = num
+    }
+    $.checkState(
+      JSUtil.isNaturalNumber(this._satoshis),
+      'Output satoshis is not a natural number'
+    )
+  }
+})
+
+Output.prototype.invalidSatoshis = function () {
+  if (this._satoshis > MAX_SAFE_INTEGER) {
+    return 'transaction txout satoshis greater than max safe integer'
+  }
+  if (this._satoshis !== this._satoshisBN.toNumber()) {
+    return 'transaction txout satoshis has corrupted value'
+  }
+  if (this._satoshis < 0) {
+    return 'transaction txout negative'
+  }
+  return false
+}
+
+Object.defineProperty(Output.prototype, 'satoshisBN', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    return this._satoshisBN
+  },
+  set: function (num) {
+    this._satoshisBN = num
+    this._satoshis = num.toNumber()
+    $.checkState(
+      JSUtil.isNaturalNumber(this._satoshis),
+      'Output satoshis is not a natural number'
+    )
+  }
+})
+
+Output.prototype.toObject = Output.prototype.toJSON = function toObject () {
+  var obj = {
+    satoshis: this.satoshis
+  }
+  obj.script = this._scriptBuffer.toString('hex')
+  return obj
+}
+
+Output.fromObject = function (data) {
+  return new Output(data)
+}
+
+Output.prototype.setScriptFromBuffer = function (buffer) {
+  this._scriptBuffer = buffer
+  try {
+    this._script = Script.fromBuffer(this._scriptBuffer)
+    this._script._isOutput = true
+  } catch (e) {
+    if (e instanceof errors.Script.InvalidBuffer) {
+      this._script = null
+    } else {
+      throw e
+    }
+  }
+}
+
+Output.prototype.setScript = function (script) {
+  if (script instanceof Script) {
+    this._scriptBuffer = script.toBuffer()
+    this._script = script
+    this._script._isOutput = true
+  } else if (_.isString(script)) {
+    this._script = Script.fromString(script)
+    this._scriptBuffer = this._script.toBuffer()
+    this._script._isOutput = true
+  } else if (Buffer.isBuffer(script)) {
+    this.setScriptFromBuffer(script)
+  } else {
+    throw new TypeError('Invalid argument type: script')
+  }
+  return this
+}
+
+Output.prototype.inspect = function () {
+  var scriptStr
+  if (this.script) {
+    scriptStr = this.script.inspect()
+  } else {
+    scriptStr = this._scriptBuffer.toString('hex')
+  }
+  return '<Output (' + this.satoshis + ' sats) ' + scriptStr + '>'
+}
+
+Output.fromBufferReader = function (br) {
+  var obj = {}
+  obj.satoshis = br.readUInt64LEBN()
+  var size = br.readVarintNum()
+  if (size !== 0) {
+    obj.script = br.read(size)
+  } else {
+    obj.script = buffer.Buffer.from([])
+  }
+  return new Output(obj)
+}
+
+Output.prototype.toBufferWriter = function (writer) {
+  if (!writer) {
+    writer = new BufferWriter()
+  }
+  writer.writeUInt64LEBN(this._satoshisBN)
+  var script = this._scriptBuffer
+  writer.writeVarintNum(script.length)
+  writer.write(script)
+  return writer
+}
+
+// 8    value
+// ???  script size (VARINT)
+// ???  script
+Output.prototype.getSize = function () {
+  var scriptSize = this.script.toBuffer().length
+  var varintSize = Varint(scriptSize).toBuffer().length
+  return 8 + varintSize + scriptSize
+}
+
+module.exports = Output

package/lib/transaction/sighash.js

@@ -0,0 +1,288 @@
+'use strict'
+
+var buffer = require('buffer')
+
+var Signature = require('../crypto/signature')
+var Script = require('../script')
+var Output = require('./output')
+var BufferReader = require('../encoding/bufferreader')
+var BufferWriter = require('../encoding/bufferwriter')
+var BN = require('../crypto/bn')
+var Hash = require('../crypto/hash')
+var ECDSA = require('../crypto/ecdsa')
+var $ = require('../util/preconditions')
+var Interpreter = require('../script/interpreter')
+var _ = require('../util/_')
+
+var SIGHASH_SINGLE_BUG = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex')
+var BITS_64_ON = 'ffffffffffffffff'
+
+// By default, we sign with sighash_forkid
+var DEFAULT_SIGN_FLAGS = Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
+
+var sighashPreimageForForkId = function (transaction, sighashType, inputNumber, subscript, satoshisBN) {
+  var input = transaction.inputs[inputNumber]
+  $.checkArgument(
+    satoshisBN instanceof BN,
+    'For ForkId=0 signatures, satoshis or complete input must be provided'
+  )
+
+  function GetPrevoutHash (tx) {
+    var writer = new BufferWriter()
+
+    _.each(tx.inputs, function (input) {
+      writer.writeReverse(input.prevTxId)
+      writer.writeUInt32LE(input.outputIndex)
+    })
+
+    var buf = writer.toBuffer()
+    var ret = Hash.sha256sha256(buf)
+    return ret
+  }
+
+  function GetSequenceHash (tx) {
+    var writer = new BufferWriter()
+
+    _.each(tx.inputs, function (input) {
+      writer.writeUInt32LE(input.sequenceNumber)
+    })
+
+    var buf = writer.toBuffer()
+    var ret = Hash.sha256sha256(buf)
+    return ret
+  }
+
+  function GetOutputsHash (tx, n) {
+    var writer = new BufferWriter()
+
+    if (_.isUndefined(n)) {
+      _.each(tx.outputs, function (output) {
+        output.toBufferWriter(writer)
+      })
+    } else {
+      tx.outputs[n].toBufferWriter(writer)
+    }
+
+    var buf = writer.toBuffer()
+    var ret = Hash.sha256sha256(buf)
+    return ret
+  }
+
+  var hashPrevouts = Buffer.alloc(32)
+  var hashSequence = Buffer.alloc(32)
+  var hashOutputs = Buffer.alloc(32)
+
+  if (!(sighashType & Signature.SIGHASH_ANYONECANPAY)) {
+    hashPrevouts = GetPrevoutHash(transaction)
+  }
+
+  if (!(sighashType & Signature.SIGHASH_ANYONECANPAY) &&
+    (sighashType & 31) !== Signature.SIGHASH_SINGLE &&
+    (sighashType & 31) !== Signature.SIGHASH_NONE) {
+    hashSequence = GetSequenceHash(transaction)
+  }
+
+  if ((sighashType & 31) !== Signature.SIGHASH_SINGLE && (sighashType & 31) !== Signature.SIGHASH_NONE) {
+    hashOutputs = GetOutputsHash(transaction)
+  } else if ((sighashType & 31) === Signature.SIGHASH_SINGLE && inputNumber < transaction.outputs.length) {
+    hashOutputs = GetOutputsHash(transaction, inputNumber)
+  }
+
+  var writer = new BufferWriter()
+
+  // Version
+  writer.writeInt32LE(transaction.version)
+
+  // Input prevouts/nSequence (none/all, depending on flags)
+  writer.write(hashPrevouts)
+  writer.write(hashSequence)
+
+  //  outpoint (32-byte hash + 4-byte little endian)
+  writer.writeReverse(input.prevTxId)
+  writer.writeUInt32LE(input.outputIndex)
+
+  // scriptCode of the input (serialized as scripts inside CTxOuts)
+  writer.writeVarintNum(subscript.toBuffer().length)
+  writer.write(subscript.toBuffer())
+
+  // value of the output spent by this input (8-byte little endian)
+  writer.writeUInt64LEBN(satoshisBN)
+
+  // nSequence of the input (4-byte little endian)
+  var sequenceNumber = input.sequenceNumber
+  writer.writeUInt32LE(sequenceNumber)
+
+  // Outputs (none/one/all, depending on flags)
+  writer.write(hashOutputs)
+
+  // Locktime
+  writer.writeUInt32LE(transaction.nLockTime)
+
+  // sighashType
+  writer.writeUInt32LE(sighashType >>> 0)
+
+  var buf = writer.toBuffer()
+  return buf
+}
+
+/**
+ * Returns a buffer with the which is hashed with sighash that needs to be signed
+ * for OP_CHECKSIG.
+ *
+ * @name Signing.sighash
+ * @param {Transaction} transaction the transaction to sign
+ * @param {number} sighashType the type of the hash
+ * @param {number} inputNumber the input index for the signature
+ * @param {Script} subscript the script that will be signed
+ * @param {satoshisBN} input's amount (for  ForkId signatures)
+ *
+ */
+var sighashPreimage = function sighashPreimage (transaction, sighashType, inputNumber, subscript, satoshisBN, flags) {
+  var Transaction = require('./transaction')
+  var Input = require('./input')
+
+  if (_.isUndefined(flags)) {
+    flags = DEFAULT_SIGN_FLAGS
+  }
+
+  // Copy transaction
+  var txcopy = Transaction.shallowCopy(transaction)
+
+  // Copy script
+  subscript = new Script(subscript)
+
+  if (flags & Interpreter.SCRIPT_ENABLE_REPLAY_PROTECTION) {
+    // Legacy chain's value for fork id must be of the form 0xffxxxx.
+    // By xoring with 0xdead, we ensure that the value will be different
+    // from the original one, even if it already starts with 0xff.
+    var forkValue = sighashType >> 8
+    var newForkValue = 0xff0000 | (forkValue ^ 0xdead)
+    sighashType = (newForkValue << 8) | (sighashType & 0xff)
+  }
+
+  if ((sighashType & Signature.SIGHASH_FORKID) && (flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID)) {
+    return sighashPreimageForForkId(txcopy, sighashType, inputNumber, subscript, satoshisBN)
+  }
+
+  // For no ForkId sighash, separators need to be removed.
+  subscript.removeCodeseparators()
+
+  var i
+
+  for (i = 0; i < txcopy.inputs.length; i++) {
+    // Blank signatures for other inputs
+    txcopy.inputs[i] = new Input(txcopy.inputs[i]).setScript(Script.empty())
+  }
+
+  txcopy.inputs[inputNumber] = new Input(txcopy.inputs[inputNumber]).setScript(subscript)
+
+  if ((sighashType & 31) === Signature.SIGHASH_NONE ||
+    (sighashType & 31) === Signature.SIGHASH_SINGLE) {
+    // clear all sequenceNumbers
+    for (i = 0; i < txcopy.inputs.length; i++) {
+      if (i !== inputNumber) {
+        txcopy.inputs[i].sequenceNumber = 0
+      }
+    }
+  }
+
+  if ((sighashType & 31) === Signature.SIGHASH_NONE) {
+    txcopy.outputs = []
+  } else if ((sighashType & 31) === Signature.SIGHASH_SINGLE) {
+    // The SIGHASH_SINGLE bug.
+    // https://bitcointalk.org/index.php?topic=260595.0
+    if (inputNumber >= txcopy.outputs.length) {
+      return SIGHASH_SINGLE_BUG
+    }
+
+    txcopy.outputs.length = inputNumber + 1
+
+    for (i = 0; i < inputNumber; i++) {
+      txcopy.outputs[i] = new Output({
+        satoshis: BN.fromBuffer(buffer.Buffer.from(BITS_64_ON, 'hex')),
+        script: Script.empty()
+      })
+    }
+  }
+
+  if (sighashType & Signature.SIGHASH_ANYONECANPAY) {
+    txcopy.inputs = [txcopy.inputs[inputNumber]]
+  }
+
+  var buf = new BufferWriter()
+    .write(txcopy.toBuffer())
+    .writeInt32LE(sighashType)
+    .toBuffer()
+  return buf
+}
+
+/**
+ * Returns a buffer of length 32 bytes with the hash that needs to be signed
+ * for OP_CHECKSIG.
+ *
+ * @name Signing.sighash
+ * @param {Transaction} transaction the transaction to sign
+ * @param {number} sighashType the type of the hash
+ * @param {number} inputNumber the input index for the signature
+ * @param {Script} subscript the script that will be signed
+ * @param {satoshisBN} input's amount (for  ForkId signatures)
+ *
+ */
+var sighash = function sighash (transaction, sighashType, inputNumber, subscript, satoshisBN, flags) {
+  var preimage = sighashPreimage(transaction, sighashType, inputNumber, subscript, satoshisBN, flags)
+  if (preimage.compare(SIGHASH_SINGLE_BUG) === 0) return preimage
+  var ret = Hash.sha256sha256(preimage)
+  ret = new BufferReader(ret).readReverse()
+  return ret
+}
+
+/**
+ * Create a signature
+ *
+ * @name Signing.sign
+ * @param {Transaction} transaction
+ * @param {PrivateKey} privateKey
+ * @param {number} sighash
+ * @param {number} inputIndex
+ * @param {Script} subscript
+ * @param {satoshisBN} input's amount
+ * @return {Signature}
+ */
+function sign (transaction, privateKey, sighashType, inputIndex, subscript, satoshisBN, flags) {
+  var hashbuf = sighash(transaction, sighashType, inputIndex, subscript, satoshisBN, flags)
+
+  var sig = ECDSA.sign(hashbuf, privateKey, 'little').set({
+    nhashtype: sighashType
+  })
+  return sig
+}
+
+/**
+ * Verify a signature
+ *
+ * @name Signing.verify
+ * @param {Transaction} transaction
+ * @param {Signature} signature
+ * @param {PublicKey} publicKey
+ * @param {number} inputIndex
+ * @param {Script} subscript
+ * @param {satoshisBN} input's amount
+ * @param {flags} verification flags
+ * @return {boolean}
+ */
+function verify (transaction, signature, publicKey, inputIndex, subscript, satoshisBN, flags) {
+  $.checkArgument(!_.isUndefined(transaction))
+  $.checkArgument(!_.isUndefined(signature) && !_.isUndefined(signature.nhashtype))
+  var hashbuf = sighash(transaction, signature.nhashtype, inputIndex, subscript, satoshisBN, flags)
+  return ECDSA.verify(hashbuf, signature, publicKey, 'little')
+}
+
+/**
+ * @namespace Signing
+ */
+module.exports = {
+  sighashPreimage: sighashPreimage,
+  sighash: sighash,
+  sign: sign,
+  verify: verify
+}