@opcat-labs/opcat 1.0.1 → 1.0.3

package/cjs/transaction/index.cjs

@@ -0,0 +1,5 @@
+var Transaction = require('./transaction.cjs');
+
+module.exports = Transaction
+
+

package/cjs/transaction/input/index.cjs

@@ -0,0 +1,34 @@
+
+var Input = require('./input.cjs');
+
+var PublicKeyInput = require('./publickey.cjs');
+var PublicKeyHashInput = require('./publickeyhash.cjs');
+var MultiSigInput = require('./multisig.cjs');
+
+
+/**
+ * Attaches the PublicKeyInput class to the Input namespace.
+ * @memberof Input
+ * @name PublicKey
+ * @alias PublicKeyInput
+ */
+Input.PublicKey = PublicKeyInput;
+
+
+/**
+ * Attaches the PublicKeyHashInput class to the Input namespace.
+ * @memberof Input
+ * @name PublicKeyHash
+ * @alias PublicKeyHashInput
+ */
+Input.PublicKeyHash = PublicKeyHashInput;
+/**
+ * Attaches the PublicKeyHashInput class to the Input namespace.
+ * @memberof Input
+ * @name MultiSig
+ * @alias MultiSigInput
+ */
+Input.MultiSig = MultiSigInput;
+
+
+module.exports = Input

package/cjs/transaction/input/input.cjs

@@ -0,0 +1,396 @@
+'use strict';
+
+var _ = require('../../util/_.cjs');
+var $ = require('../../util/preconditions.cjs');
+var errors = require('../../errors/index.cjs');
+var BufferWriter = require('../../encoding/bufferwriter.cjs');
+var JSUtil = require('../../util/js.cjs');
+var Script = require('../../script/index.cjs');
+var Sighash = require('../sighash.cjs');
+var Output = require('../output.cjs');
+var Signature = require('../../crypto/signature.cjs');
+var TransactionSignature = require('../signature.cjs');
+var Hash = require('../../crypto/hash.cjs');
+var PrivateKey = require('../../privatekey.cjs');
+
+var MAXINT = 0xffffffff; // Math.pow(2, 32) - 1;
+var DEFAULT_RBF_SEQNUMBER = MAXINT - 2;
+var DEFAULT_SEQNUMBER = MAXINT;
+var DEFAULT_LOCKTIME_SEQNUMBER = MAXINT - 1;
+
+/**
+ * Creates an Input instance from parameters.
+ * @constructor
+ * @param {Object} params - Input parameters object
+ * @param {string|Buffer} params.prevTxId - Previous transaction ID (hex string or Buffer)
+ * @param {number} params.outputIndex - Output index in previous transaction
+ * @param {Output} [params.output] - Output instance or output parameters
+ * @param {number} [params.sequenceNumber] - Sequence number (defaults to DEFAULT_SEQNUMBER)
+ * @param {Script|Buffer|string} [params.script] - Script instance, buffer or hex string
+ * @returns {Input} New Input instance or initialized instance if params provided.
+ */
+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;
+
+/**
+ * Gets or sets the script associated with this input.
+ * @memberof Input.prototype
+ * @name script
+ * @return {Script}
+ */
+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;
+  },
+});
+
+/**
+ * Creates an Input instance from a plain JavaScript object.
+ * @param {Object} params - Input parameters object
+ * @param {string|Buffer} params.prevTxId - Previous transaction ID (hex string or Buffer)
+ * @param {number} params.outputIndex - Output index in previous transaction
+ * @param {Output} [params.output] - Output instance or output parameters
+ * @param {number} [params.sequenceNumber] - Sequence number (defaults to DEFAULT_SEQNUMBER)
+ * @param {Script|Buffer|string} [params.script] - Script instance, buffer or hex string
+ * @returns {Input} The created Input instance.
+ * @throws {Error} Will throw if the argument is not an object.
+ */
+Input.fromObject = function (params) {
+  $.checkArgument(_.isObject(params));
+  var input = new Input();
+  return input._fromObject(params);
+};
+
+/**
+ * Creates an Input instance from an object containing transaction input parameters.
+ * Validates required fields (prevTxId, outputIndex) and converts hex strings to Buffers.
+ * Handles optional parameters with defaults (sequenceNumber, script).
+ * @param {Object} params - Input parameters object
+ * @param {string|Buffer} params.prevTxId - Previous transaction ID (hex string or Buffer)
+ * @param {number} params.outputIndex - Output index in previous transaction
+ * @param {Output} [params.output] - Output instance or output parameters
+ * @param {number} [params.sequenceNumber] - Sequence number (defaults to DEFAULT_SEQNUMBER)
+ * @param {Script|Buffer|string} [params.script] - Script instance, buffer or hex string
+ * @throws {errors.Transaction.Input.InvalidParams} If required params are missing
+ * @returns {Input} Returns the Input instance for chaining
+ * @private
+ */
+Input.prototype._fromObject = function (params) {
+
+  if(_.isUndefined(params.prevTxId)
+    || _.isUndefined(params.outputIndex)) {
+     throw new errors.Transaction.Input.InvalidParams('require prevTxId and outputIndex');
+  }
+  var prevTxId;
+  if (_.isString(params.prevTxId) && JSUtil.isHexa(params.prevTxId)) {
+    prevTxId = 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;
+  this.setScript(params.scriptBuffer || params.script || Script.empty());
+  return this;
+};
+
+
+/**
+ * Converts the Input instance to a plain object for JSON serialization.
+ * Includes prevTxId, outputIndex, sequenceNumber, and script as hex strings.
+ * Optionally adds human-readable scriptString if script is valid,
+ * and includes the output object if present.
+ * @returns {Object} A plain object representation of the Input.
+ */
+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;
+};
+
+/**
+ * Creates an Input instance from a BufferReader.
+ * @param {BufferReader} br - The buffer reader containing input data.
+ * @returns {Input} The parsed Input object with properties:
+ *   - prevTxId: Reversed 32-byte previous transaction ID.
+ *   - outputIndex: LE uint32 output index.
+ *   - _scriptBuffer: Var-length script buffer.
+ *   - sequenceNumber: LE uint32 sequence number.
+ * @note TODO: Return specialized input types (CoinbaseInput, PublicKeyHashInput, etc.).
+ * @static
+ */
+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, etc.
+  return input;
+};
+
+/**
+ * Serializes the input to a BufferWriter.
+ * @param {boolean} hashScriptSig - Whether to hash the script (true) or include it directly (false).
+ * @param {BufferWriter} [writer] - Optional BufferWriter instance to write to.
+ * @returns {BufferWriter} The BufferWriter containing the serialized input.
+ */
+Input.prototype.toBufferWriter = function (hashScriptSig, writer) {
+  $.checkArgument(typeof hashScriptSig === 'boolean', 'hashScriptSig should be boolean')
+  if (!writer) {
+    writer = new BufferWriter()
+  }
+  writer.writeReverse(this.prevTxId)
+  writer.writeUInt32LE(this.outputIndex)
+  var script = this._scriptBuffer
+  if(hashScriptSig) {
+    writer.write(Hash.sha256(script))
+  } else {
+    writer.writeVarintNum(script.length)
+    writer.write(script)
+  }
+  writer.writeUInt32LE(this.sequenceNumber)
+  return writer
+}
+
+
+/**
+ * Converts the input to a prevout format (txid + output index) as a buffer.
+ * @returns {Buffer} The serialized prevout data.
+ */
+Input.prototype.toPrevout = function () {
+  let writer = new BufferWriter()
+  writer.writeReverse(this.prevTxId)
+  writer.writeUInt32LE(this.outputIndex)
+  return writer.toBuffer()
+}
+
+
+/**
+ * Sets the script for this input.
+ * @param {Script|string|Buffer|null} script - Can be a Script object, hex string, human-readable string, Buffer, or null (for empty script)
+ * @returns {Input} Returns the Input instance for chaining
+ * @throws {TypeError} If script is of invalid type
+ */
+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.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.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 | Array} privateKeys - 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
+ */
+Input.prototype.getSignatures = function (transaction, privateKeys, inputIndex, sigtype) {
+  $.checkState(this.output instanceof Output);
+  sigtype = sigtype || Signature.SIGHASH_ALL;
+  var results = [];
+  if (privateKeys instanceof PrivateKey) {
+    results.push(
+      new TransactionSignature({
+        publicKey: privateKeys.publicKey,
+        prevTxId: this.prevTxId,
+        outputIndex: this.outputIndex,
+        inputIndex: inputIndex,
+        signature: Sighash.sign(
+          transaction,
+          privateKeys,
+          sigtype,
+          inputIndex,
+        ),
+        sigtype: sigtype,
+      }),
+    );
+  } else if (_.isArray(privateKeys)) {
+    var self = this;
+
+    _.each(privateKeys, function (privateKey, index) {
+      var sigtype_ = sigtype;
+      if (_.isArray(sigtype)) {
+        sigtype_ = sigtype[index] || Signature.SIGHASH_ALL;
+      }
+      results.push(
+        new TransactionSignature({
+          publicKey: privateKey.publicKey,
+          prevTxId: self.prevTxId,
+          outputIndex: self.outputIndex,
+          inputIndex: inputIndex,
+          signature: Sighash.sign(
+            transaction,
+            privateKey,
+            sigtype_,
+            inputIndex,
+          ),
+          sigtype: sigtype_,
+        }),
+      );
+    });
+  }
+  return results;
+};
+
+/**
+ * Retrieve preimage for the Input.
+ *
+ * @param {Transaction} transaction - the transaction to be signed
+ * @param {number} inputIndex - the index of this input in the provided transaction
+ * @param {number} sigType - defaults to Signature.SIGHASH_ALL
+ * @param {boolean} isLowS - true if the sig hash is safe for low s.
+ */
+Input.prototype.getPreimage = function (transaction, inputIndex, sigtype, isLowS) {
+  $.checkState(this.output instanceof Output);
+  sigtype = sigtype || Signature.SIGHASH_ALL;
+  isLowS = isLowS || false;
+  return isLowS
+    ? Sighash.getLowSSighashPreimage(transaction, sigtype, inputIndex)
+    : Sighash.sighashPreimage(transaction, sigtype, inputIndex);
+};
+
+/**
+ * Abstract method that throws an error when invoked. Must be implemented by subclasses
+ * to determine if all required signatures are present on this input.
+ * @throws {AbstractMethodInvoked} Always throws to indicate abstract method usage
+ * @abstract
+ */
+Input.prototype.isFullySigned = function () {
+  throw new errors.AbstractMethodInvoked('Input#isFullySigned');
+};
+
+/**
+ * Checks if the input is final (has maximum sequence number).
+ * @returns {boolean} True if the input is final, false otherwise.
+ */
+Input.prototype.isFinal = function () {
+  return this.sequenceNumber === Input.MAXINT;
+};
+
+/**
+ * Abstract method to add a signature to the transaction input.
+ * Must be implemented by concrete input types.
+ * @param {Object} transaction - The transaction to sign
+ * @param {Object} signature - The signature to add
+ * @abstract
+ */
+Input.prototype.addSignature = function (_transaction, _signature) {
+};
+
+/**
+ * Clears all signatures from the input.
+ * @abstract
+ */
+Input.prototype.clearSignatures = function () {
+
+};
+
+/**
+ * Verifies if a signature is valid for this input in the given transaction.
+ * Note: Temporarily modifies the signature object by setting nhashtype from sigtype.
+ * 
+ * @param {Object} transaction - The transaction to verify against
+ * @param {TransactionSignature} signature - Signature object containing signature, publicKey, etc.
+ * @returns {boolean} True if the signature is valid, false otherwise
+ */
+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
+  );
+};
+
+/**
+ * Estimates the size of the input in bytes by converting it to a buffer.
+ * @returns {number} The length of the serialized buffer in bytes.
+ * @private
+ */
+Input.prototype._estimateSize = function () {
+  return this.toBufferWriter(false).toBuffer().length;
+};
+
+
+module.exports = Input;

package/{lib/transaction/input/multisig.js → cjs/transaction/input/multisig.cjs}

@@ -1,20 +1,27 @@
 'use strict';
 
-var _ = require('../../util/_');
+var _ = require('../../util/_.cjs');
 var inherits = require('inherits');
-var Input = require('./input');
-var Output = require('../output');
-var $ = require('../../util/preconditions');
+var Input = require('./input.cjs');
+var Output = require('../output.cjs');
+var $ = require('../../util/preconditions.cjs');
+
+var Script = require('../../script/index.cjs');
+var Signature = require('../../crypto/signature.cjs');
+var Sighash = require('../sighash.cjs');
+var TransactionSignature = require('../signature.cjs');
+var PublicKey = require('../../publickey.cjs');
+var Varint = require('../../encoding/varint.cjs');
 
-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');
 
 /**
+ * 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);
@@ -42,6 +49,11 @@ function MultiSigInput(input, pubkeys, threshold, signatures) {
 }
 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;
@@ -52,6 +64,12 @@ MultiSigInput.prototype.toObject = function () {
   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) {
@@ -61,6 +79,11 @@ MultiSigInput.prototype._deserializeSignatures = function (signatures) {
   });
 };
 
+/**
+ * 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) {
@@ -70,6 +93,16 @@ MultiSigInput.prototype._serializeSignatures = function () {
   });
 };
 
+/**
+ * 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;
@@ -99,6 +132,13 @@ MultiSigInput.prototype.getSignatures = function (transaction, privateKey, index
   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(
@@ -111,11 +151,21 @@ MultiSigInput.prototype.addSignature = function (transaction, signature) {
   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) {
@@ -127,19 +177,36 @@ MultiSigInput.prototype._createSignatures = function () {
   );
 };
 
+/**
+ * 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,
@@ -150,6 +217,10 @@ MultiSigInput.prototype.countSignatures = function () {
   );
 };
 
+/**
+ * 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) {
@@ -157,8 +228,19 @@ MultiSigInput.prototype.publicKeysWithoutSignature = function () {
   });
 };
 
+/**
+ * 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
+// FIXME: Refactor signature so this is not necessary
   signature.signature.nhashtype = signature.sigtype;
   return Sighash.verify(
     transaction,
@@ -171,13 +253,15 @@ MultiSigInput.prototype.isValidSignature = function (transaction, signature) {
 };
 
 /**
- *
- * @param {Buffer[]} signatures
- * @param {PublicKey[]} publicKeys
- * @param {Transaction} transaction
- * @param {Integer} inputIndex
- * @param {Input} input
- * @returns {TransactionSignature[]}
+ * 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,
@@ -232,8 +316,18 @@ MultiSigInput.normalizeSignatures = function (
 //      <=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;