@opcat-labs/opcat 1.0.0 → 1.0.2

package/esm/transaction/input/multisig.js

@@ -0,0 +1,335 @@
+'use strict';
+
+import _ from '../../util/_.js';
+import inherits from 'inherits';
+import Input from './input.js';
+import Output from '../output.js';
+import $ from '../../util/preconditions.js';
+import Script from '../../script/index.js';
+import Signature from '../../crypto/signature.js';
+import Sighash from '../sighash.js';
+import TransactionSignature from '../signature.js';
+import PublicKey from '../../publickey.js';
+import Varint from '../../encoding/varint.js';
+
+
+/**
+ * Represents a MultiSigInput for a transaction.
+ * @constructor
+ * @param {Object} input - The input object containing publicKeys, threshold, and signatures.
+ * @param {Array} pubkeys - Array of public keys (optional, defaults to input.publicKeys).
+ * @param {number} threshold - Required number of signatures (optional, defaults to input.threshold).
+ * @param {Array} signatures - Array of signatures (optional, defaults to input.signatures).
+ * @description Validates that provided public keys match the output script and initializes signatures.
+ */
+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);
+
+/**
+ * Converts the MultiSigInput instance to a plain object representation.
+ * Includes threshold, publicKeys (converted to strings), and serialized signatures.
+ * @returns {Object} The plain object representation of the MultiSigInput.
+ */
+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;
+};
+
+/**
+ * Deserializes an array of signature strings into TransactionSignature objects.
+ * @private
+ * @param {Array<string>} signatures - Array of signature strings to deserialize
+ * @returns {Array<TransactionSignature|undefined>} Array of TransactionSignature objects (undefined for null/empty signatures)
+ */
+MultiSigInput.prototype._deserializeSignatures = function (signatures) {
+  return _.map(signatures, function (signature) {
+    if (!signature) {
+      return undefined;
+    }
+    return new TransactionSignature(signature);
+  });
+};
+
+/**
+ * Serializes the signatures array by converting each signature to a plain object.
+ * @returns {Array<Object|undefined>} An array of signature objects or undefined values.
+ * @private
+ */
+MultiSigInput.prototype._serializeSignatures = function () {
+  return _.map(this.signatures, function (signature) {
+    if (!signature) {
+      return undefined;
+    }
+    return signature.toObject();
+  });
+};
+
+/**
+ * Gets signatures for a MultiSigInput by signing the transaction with the provided private key.
+ * Only signs for public keys that match the private key's public key.
+ * 
+ * @param {Transaction} transaction - The transaction to sign
+ * @param {PrivateKey} privateKey - The private key used for signing
+ * @param {number} index - The input index
+ * @param {number} [sigtype=Signature.SIGHASH_ALL] - The signature type
+ * @returns {TransactionSignature[]} Array of transaction signatures
+ */
+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;
+};
+
+/**
+ * Adds a signature to the MultiSigInput if valid and not already fully signed.
+ * @param {Object} transaction - The transaction to validate the signature against.
+ * @param {Object} signature - The signature object containing publicKey and signature data.
+ * @throws {Error} If already fully signed, no matching public key, or invalid signature.
+ * @returns {MultiSigInput} Returns the instance for chaining.
+ */
+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;
+};
+
+/**
+ * Updates the multisig input script by rebuilding it with current public keys, threshold, and signatures.
+ * @returns {MultiSigInput} Returns the instance for chaining.
+ */
+MultiSigInput.prototype._updateScript = function () {
+  this.setScript(Script.buildMultisigIn(this.publicKeys, this.threshold, this._createSignatures()));
+  return this;
+};
+
+/**
+ * Creates DER-encoded signatures from the input's signature data.
+ * Filters out undefined signatures and converts each valid signature to a Buffer
+ * containing the DER-encoded signature followed by its sigtype byte.
+ * @returns {Buffer[]} Array of signature Buffers
+ */
+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])]);
+    },
+  );
+};
+
+/**
+ * Clears all signatures from the MultiSigInput by resetting the signatures array
+ * and updating the script. The signatures array length matches the publicKeys array.
+ */
+MultiSigInput.prototype.clearSignatures = function () {
+  this.signatures = new Array(this.publicKeys.length);
+  this._updateScript();
+};
+
+/**
+ * Checks if the MultiSigInput is fully signed by comparing the number of signatures
+ * with the required threshold.
+ * @returns {boolean} True if the input has enough signatures, false otherwise.
+ */
+MultiSigInput.prototype.isFullySigned = function () {
+  return this.countSignatures() === this.threshold;
+};
+
+/**
+ * Returns the number of missing signatures required to meet the threshold.
+ * @returns {number} The count of missing signatures.
+ */
+MultiSigInput.prototype.countMissingSignatures = function () {
+  return this.threshold - this.countSignatures();
+};
+
+/**
+ * Counts the number of valid signatures in the MultiSigInput.
+ * @returns {number} The count of non-null/undefined signatures.
+ */
+MultiSigInput.prototype.countSignatures = function () {
+  return _.reduce(
+    this.signatures,
+    function (sum, signature) {
+      return sum + !!signature;
+    },
+    0,
+  );
+};
+
+/**
+ * Returns an array of public keys that haven't been signed yet in this MultiSigInput.
+ * @returns {Array} Array of unsigned public keys
+ */
+MultiSigInput.prototype.publicKeysWithoutSignature = function () {
+  var self = this;
+  return _.filter(this.publicKeys, function (publicKey) {
+    return !self.signatures[self.publicKeyIndex[publicKey.toString()]];
+  });
+};
+
+/**
+ * Verifies a signature for a MultiSigInput transaction.
+ * 
+ * @param {Object} transaction - The transaction to verify.
+ * @param {Object} signature - The signature object containing signature data.
+ * @param {Buffer} signature.signature - The signature to verify.
+ * @param {Buffer} signature.publicKey - The public key corresponding to the signature.
+ * @param {number} signature.inputIndex - The index of the input being signed.
+ * @param {number} signature.sigtype - The signature type (assigned to nhashtype as a workaround).
+ * @returns {boolean} True if the signature is valid, false otherwise.
+ */
+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,
+  );
+};
+
+/**
+ * Normalizes signatures for a MultiSigInput by matching each public key with its corresponding signature.
+ * Filters and validates signatures against the provided public keys and transaction.
+ * 
+ * @param {Object} transaction - The transaction to verify against.
+ * @param {Object} input - The input containing prevTxId and outputIndex.
+ * @param {number} inputIndex - The index of the input in the transaction.
+ * @param {Array<Buffer>} signatures - Array of signature buffers to normalize.
+ * @param {Array<PublicKey>} publicKeys - Array of public keys to match signatures against.
+ * @returns {Array<TransactionSignature|null>} Array of matched signatures or null for unmatched keys.
+ */
+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
+/**
+ * The byte size of a single signature in a MultiSig input.
+ * @constant
+ */
+MultiSigInput.SIGNATURE_SIZE = 73;
+
+/**
+ * Estimates the byte size of a MultiSigInput, including the base input size,
+ * script size (with threshold-based signature count), and varint overhead.
+ * @returns {number} The estimated size in bytes.
+ * @private
+ */
+MultiSigInput.prototype._estimateSize = function () {
+  var scriptSize = 1 + this.threshold * MultiSigInput.SIGNATURE_SIZE;
+  return Input.BASE_SIZE + Varint(scriptSize).toBuffer().length + scriptSize;
+};
+
+export default MultiSigInput;

package/esm/transaction/input/publickey.js

@@ -0,0 +1,108 @@
+'use strict';
+
+import inherits from 'inherits';
+import $ from '../../util/preconditions.js';
+import Input from './input.js';
+import Output from '../output.js';
+import Sighash from '../sighash.js';
+import Script from '../../script/index.js';
+import Signature from '../../crypto/signature.js';
+import TransactionSignature from '../signature.js';
+
+/**
+ * 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 [];
+};
+
+
+/**
+ * Adds a signature to the public key input after validating it.
+ * @param {Object} transaction - The transaction to validate against.
+ * @param {TransactionSignature} signature - The signature object containing signature data and type.
+ * @returns {PublicKeyInput} Returns the instance for chaining.
+ * @throws {Error} Throws if the signature is invalid.
+ */
+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;
+};
+
+
+/**
+ * Clears all signatures from this input by setting an empty script.
+ * @returns {PublicKeyInput} The instance for chaining.
+ */
+PublicKeyInput.prototype.clearSignatures = function () {
+  this.setScript(Script.empty());
+  return this;
+};
+
+
+/**
+ * Checks if the public key input is fully signed by verifying the script contains a public key.
+ * @returns {boolean} True if the script contains a public key, false otherwise.
+ */
+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
+/**
+ * The maximum allowed size (in bytes) for a public key script in a transaction input.
+ * @constant {number}
+ */
+PublicKeyInput.SCRIPT_MAX_SIZE = 74;
+
+/**
+ * Estimates the byte size required for this public key input.
+ * @returns {number} The estimated size in bytes (base input size + max script size).
+ * @private
+ */
+PublicKeyInput.prototype._estimateSize = function () {
+  return Input.BASE_SIZE + PublicKeyInput.SCRIPT_MAX_SIZE;
+};
+
+export default PublicKeyInput;

package/esm/transaction/input/publickeyhash.js

@@ -0,0 +1,124 @@
+'use strict';
+
+import inherits from 'inherits';
+import $ from '../../util/preconditions.js';
+import Hash from '../../crypto/hash.js';
+import Input from './input.js';
+import Output from '../output.js';
+import Sighash from '../sighash.js';
+import Script from '../../script/index.js';
+import Signature from '../../crypto/signature.js';
+import TransactionSignature from '../signature.js';
+
+/**
+ * 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 [];
+};
+
+
+/**
+ * Adds a signature to the input and updates the script.
+ * @param {Transaction} transaction - The transaction to validate against.
+ * @param {TransactionSignature} signature - The signature object containing publicKey, signature (DER format), and sigtype.
+ * @returns {PublicKeyHashInput} Returns the instance for chaining.
+ * @throws {Error} Throws if the signature is invalid.
+ */
+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
+/**
+ * The maximum allowed size (in bytes) for a public key hash script.
+ * @constant
+ */
+PublicKeyHashInput.SCRIPT_MAX_SIZE = 140;
+
+/**
+ * Estimates the byte size of this public key hash input.
+ * @returns {number} The estimated size in bytes (base input size + max script size).
+ * @private
+ */
+PublicKeyHashInput.prototype._estimateSize = function () {
+  return Input.BASE_SIZE + PublicKeyHashInput.SCRIPT_MAX_SIZE;
+};
+
+export default PublicKeyHashInput;