@opcat-labs/opcat 1.0.0

package/lib/transaction/sighash.js

@@ -0,0 +1,167 @@
+'use strict'
+var Signature = require('../crypto/signature')
+var Script = require('../script')
+var Output = require('./output')
+var BufferReader = require('../encoding/bufferreader')
+var BufferWriter = require('../encoding/bufferwriter')
+var Hash = require('../crypto/hash')
+var ECDSA = require('../crypto/ecdsa')
+var $ = require('../util/preconditions')
+var _ = require('../util/_')
+
+var SIGHASH_SINGLE_BUG = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex')
+/**
+ * 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) {
+  // Check that all inputs have an output, prevent shallow transaction
+  _.each(transaction.inputs, function (input) {
+    $.checkState(input.output instanceof Output, 'input.output must be an instance of Output')
+  })
+  $.checkArgument(sighashType === Signature.SIGHASH_ALL, 'only SIGHASH_ALL is supported')
+  $.checkArgument(inputNumber < transaction.inputs.length, 'inputNumber must be less than the number of inputs')
+
+  var nVersion
+  var prevouts = []
+  var spentScriptHash
+  var spentDataHash
+  var spentAmount
+  var sequence
+  var spentAmounts = []
+  var spentScriptHashes = []
+  var spentDataHashes = []
+  var sequences = []
+  var outputs = []
+  var inputIndex
+  var nLockTime
+  var sighashTypeBuf
+
+  const getSeparatedScript = function (script) {
+    const separatedScript = new Script(script)
+    separatedScript.removeCodeseparators()
+    return separatedScript
+  }
+
+  // all inputs
+  _.each(transaction.inputs, function (input) {
+    prevouts.push(input.toPrevout())
+    spentAmounts.push(new BufferWriter().writeUInt64LEBN(input.output.satoshisBN).toBuffer())
+    spentScriptHashes.push(Hash.sha256(getSeparatedScript(input.output.script).toBuffer()))
+    spentDataHashes.push(Hash.sha256(input.output.data))
+    sequences.push(new BufferWriter().writeUInt32LE(input.sequenceNumber).toBuffer())
+  })
+
+  // current input
+  spentScriptHash = Hash.sha256(getSeparatedScript(transaction.inputs[inputNumber].output.script).toBuffer())
+  spentDataHash = Hash.sha256(transaction.inputs[inputNumber].output.data)
+  spentAmount = new BufferWriter().writeUInt64LEBN(transaction.inputs[inputNumber].output.satoshisBN).toBuffer()
+  sequence = new BufferWriter().writeUInt32LE(transaction.inputs[inputNumber].sequenceNumber).toBuffer()
+  inputIndex = new BufferWriter().writeUInt32LE(inputNumber).toBuffer()
+  sighashTypeBuf = new BufferWriter().writeUInt32LE(sighashType).toBuffer()
+
+  // all outputs
+  _.each(transaction.outputs, function (output) {
+    outputs.push(output.toBufferWriter(true).toBuffer())
+  })
+
+  // tx.version
+  nVersion = new BufferWriter().writeUInt32LE(transaction.version).toBuffer()
+  // tx.nLockTime
+  nLockTime = new BufferWriter().writeUInt32LE(transaction.nLockTime).toBuffer()
+
+  let bw = new BufferWriter()
+
+  bw.write(nVersion)
+  bw.write(Hash.sha256sha256(Buffer.concat([...prevouts])))
+  bw.write(spentScriptHash)
+  bw.write(spentDataHash)
+  bw.write(spentAmount)
+  bw.write(sequence)
+
+  bw.write(Hash.sha256sha256(Buffer.concat([...spentAmounts])))
+  bw.write(Hash.sha256sha256(Buffer.concat([...spentScriptHashes])))
+  bw.write(Hash.sha256sha256(Buffer.concat([...spentDataHashes])))
+  bw.write(Hash.sha256sha256(Buffer.concat([...sequences])))
+  bw.write(Hash.sha256sha256(Buffer.concat([...outputs])))
+
+  bw.write(inputIndex)
+  bw.write(nLockTime)
+  bw.write(sighashTypeBuf)
+
+  return bw.toBuffer()
+}
+
+/**
+ * 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
+ *
+ */
+var sighash = function sighash (transaction, sighashType, inputNumber) {
+  var preimage = sighashPreimage(transaction, sighashType, inputNumber)
+  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
+ * @return {Signature}
+ */
+function sign (transaction, privateKey, sighashType, inputIndex) {
+  var hashbuf = sighash(transaction, sighashType, inputIndex)
+
+  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) {
+  $.checkArgument(!_.isUndefined(transaction))
+  $.checkArgument(!_.isUndefined(signature) && !_.isUndefined(signature.nhashtype))
+  var hashbuf = sighash(transaction, signature.nhashtype, inputIndex)
+  return ECDSA.verify(hashbuf, signature, publicKey, 'little')
+}
+
+/**
+ * @namespace Signing
+ */
+module.exports = {
+  sighashPreimage: sighashPreimage,
+  sighash: sighash,
+  sign: sign,
+  verify: verify
+}

package/lib/transaction/signature.js

@@ -0,0 +1,97 @@
+'use strict';
+
+var _ = require('../util/_');
+var $ = require('../util/preconditions');
+var inherits = require('inherits');
+var JSUtil = require('../util/js');
+
+var PublicKey = require('../publickey');
+var errors = require('../errors');
+var Signature = require('../crypto/signature');
+
+/**
+ * @desc
+ * Wrapper around Signature with fields related to signing a transaction specifically
+ *
+ * @param {Object|string|TransactionSignature} arg
+ * @constructor
+ */
+function TransactionSignature(arg) {
+  if (!(this instanceof TransactionSignature)) {
+    return new TransactionSignature(arg);
+  }
+  if (arg instanceof TransactionSignature) {
+    return arg;
+  }
+  if (_.isObject(arg)) {
+    return this._fromObject(arg);
+  }
+  throw new errors.InvalidArgument('TransactionSignatures must be instantiated from an object');
+}
+inherits(TransactionSignature, Signature);
+
+TransactionSignature.prototype._fromObject = function (arg) {
+  this._checkObjectArgs(arg);
+  this.publicKey = new PublicKey(arg.publicKey);
+  this.prevTxId = Buffer.isBuffer(arg.prevTxId) ? arg.prevTxId : Buffer.from(arg.prevTxId, 'hex');
+  this.outputIndex = arg.outputIndex;
+  this.inputIndex = arg.inputIndex;
+  this.signature =
+    arg.signature instanceof Signature
+      ? arg.signature
+      : Buffer.isBuffer(arg.signature)
+      ? Signature.fromBuffer(arg.signature)
+      : Signature.fromString(arg.signature);
+  this.sigtype = arg.sigtype;
+  return this;
+};
+
+TransactionSignature.prototype._checkObjectArgs = function (arg) {
+  $.checkArgument(PublicKey(arg.publicKey), 'publicKey');
+  $.checkArgument(!_.isUndefined(arg.inputIndex), 'inputIndex');
+  $.checkArgument(!_.isUndefined(arg.outputIndex), 'outputIndex');
+  $.checkState(_.isNumber(arg.inputIndex), 'inputIndex must be a number');
+  $.checkState(_.isNumber(arg.outputIndex), 'outputIndex must be a number');
+  $.checkArgument(arg.signature, 'signature');
+  $.checkArgument(arg.prevTxId, 'prevTxId');
+  $.checkState(
+    arg.signature instanceof Signature ||
+      Buffer.isBuffer(arg.signature) ||
+      JSUtil.isHexa(arg.signature),
+    'signature must be a buffer or hexa value',
+  );
+  $.checkState(
+    Buffer.isBuffer(arg.prevTxId) || JSUtil.isHexa(arg.prevTxId),
+    'prevTxId must be a buffer or hexa value',
+  );
+  $.checkArgument(arg.sigtype, 'sigtype');
+  $.checkState(_.isNumber(arg.sigtype), 'sigtype must be a number');
+};
+
+/**
+ * Serializes a transaction to a plain JS object
+ * @return {Object}
+ */
+TransactionSignature.prototype.toObject = TransactionSignature.prototype.toJSON =
+  function toObject() {
+    return {
+      publicKey: this.publicKey.toString(),
+      prevTxId: this.prevTxId.toString('hex'),
+      outputIndex: this.outputIndex,
+      inputIndex: this.inputIndex,
+      signature: this.signature.toString(),
+      sigtype: this.sigtype,
+    };
+  };
+
+/**
+ * Builds a TransactionSignature from an object
+ * @param {Object} object
+ * @return {TransactionSignature}
+ */
+TransactionSignature.fromObject = function (object) {
+  $.checkArgument(object);
+  return new TransactionSignature(object);
+};
+
+module.exports = TransactionSignature;