@opcat-labs/opcat 1.0.0

package/lib/transaction/input/multisig.js

@@ -0,0 +1,242 @@
+'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;
+
+  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,
+          ),
+          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,
+      );
+
+      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/publickey.js

@@ -0,0 +1,100 @@
+'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;
+  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,
+        ),
+        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,118 @@
+'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;
+
+  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,
+        ),
+        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)
+// 65   uncompressed public key
+//
+// 4    sequence number
+PublicKeyHashInput.SCRIPT_MAX_SIZE = 140;
+
+PublicKeyHashInput.prototype._estimateSize = function () {
+  return Input.BASE_SIZE + PublicKeyHashInput.SCRIPT_MAX_SIZE;
+};
+
+module.exports = PublicKeyHashInput;

package/lib/transaction/output.js

@@ -0,0 +1,231 @@
+'use strict';
+
+var _ = require('../util/_');
+var BN = require('../crypto/bn');
+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 Hash = require('../crypto/hash')
+
+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.setScriptFromBuffer(args.script);
+    } else {
+      var script;
+      if (_.isString(args.script) && JSUtil.isHexa(args.script)) {
+        script = Buffer.from(args.script, 'hex');
+      } else {
+        script = args.script;
+      }
+      this.setScript(script);
+    }
+    this.setData(args.data)
+  } else {
+    throw new TypeError('Unrecognized argument for Output');
+  }
+}
+
+Object.defineProperty(Output.prototype, 'script', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    return this._script;
+  },
+});
+
+Object.defineProperty(Output.prototype, 'data', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    return this._data;
+  },
+});
+
+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._script.toBuffer().toString('hex');
+  obj.data = this._data.toString('hex')
+  return obj;
+};
+
+Output.prototype.setData = function (data) {
+  if (!data) {
+    this._data = Buffer.from([])
+    return;
+  }
+  if (Buffer.isBuffer(data)) {
+    this._data = data
+  } else if (_.isString(data) && JSUtil.isHexa(data)) {
+    this._data = Buffer.from(data, 'hex')
+  } else {
+    throw new TypeError('Invalid argument type: data for output.setData')
+  }
+}
+
+Output.fromObject = function (data) {
+  return new Output(data);
+};
+
+Output.prototype.setScriptFromBuffer = function (buffer) {
+  try {
+    this._script = Script.fromBuffer(buffer);
+    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._script = script;
+    this._script._isOutput = true;
+  } else if (_.isString(script)) {
+    this._script = Script.fromString(script);
+    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();
+  }
+  return '<Output (' + this.satoshis + ' sats) ' + scriptStr + '>';
+};
+
+Output.fromBufferReader = function (br) {
+  var obj = {}
+  obj.satoshis = br.readUInt64LEBN()
+  var scriptSize = br.readVarintNum()
+  if (scriptSize !== 0) {
+    if (br.remaining() < scriptSize) {
+      throw new TypeError('Unrecognized Output')
+    }
+    obj.script = br.read(scriptSize)
+  } else {
+    obj.script = Buffer.from([])
+  }
+  var dataSize = br.readVarintNum()
+  if (dataSize !== 0) {
+    if (br.remaining() < dataSize) {
+      throw new TypeError('Unrecognized Output')
+    }
+    obj.data = br.read(dataSize)
+  } else {
+    obj.data = Buffer.from([])
+  }
+  return new Output(obj)
+}
+
+Output.prototype.toBufferWriter = function (hashScriptPubkey, writer) {
+    $.checkArgument(typeof hashScriptPubkey === 'boolean', 'hashScriptSig should be boolean')
+  if (!writer) {
+    writer = new BufferWriter();
+  }
+  writer.writeUInt64LEBN(this._satoshisBN);
+  var script = this._script.toBuffer();
+  var data = this._data
+  if(hashScriptPubkey) {
+    writer.write(Hash.sha256(script))
+    writer.write(Hash.sha256(data))
+  } else {
+    writer.writeVarintNum(script.length);
+    writer.write(script);
+    writer.writeVarintNum(data.length)
+    writer.write(data)
+  }
+
+
+  return writer
+};
+
+// 8    value
+// ???  script size (VARINT)
+// ???  script
+/**
+ * Calculates the total size of the output in bytes.
+ * Includes the script size, data size, and their respective varint sizes,
+ * plus a fixed 8-byte overhead.
+ * @returns {number} The total output size in bytes.
+ */
+Output.prototype.getSize = function () {
+  var scriptSize = this.script.toBuffer().length;
+  var dataSize = this.data.length
+  var varintSize = Varint(scriptSize).toBuffer().length + Varint(dataSize).toBuffer().length
+  return 8 + varintSize + scriptSize + dataSize
+};
+
+Output.prototype.clone = function () {
+  return Output.fromObject(this.toObject());
+}
+
+module.exports = Output;