@opcat-labs/opcat 1.0.0 → 1.0.2

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

@@ -2,14 +2,14 @@
 
 var inherits = require('inherits');
 
-var $ = require('../../util/preconditions');
+var $ = require('../../util/preconditions.cjs');
 
-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');
+var Input = require('./input.cjs');
+var Output = require('../output.cjs');
+var Sighash = require('../sighash.cjs');
+var Script = require('../../script/index.cjs');
+var Signature = require('../../crypto/signature.cjs');
+var TransactionSignature = require('../signature.cjs');
 
 /**
  * Represents a special kind of input of PayToPublicKey kind.
@@ -24,7 +24,7 @@ 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
+ * @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) {
@@ -51,14 +51,13 @@ PublicKeyInput.prototype.getSignatures = function (transaction, privateKey, inde
   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
+ * 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');
@@ -66,18 +65,20 @@ PublicKeyInput.prototype.addSignature = function (transaction, signature) {
   return this;
 };
 
+
 /**
- * Clear the input's signature
- * @return {PublicKeyHashInput} this, for chaining
+ * 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;
 };
 
+
 /**
- * Query whether the input is signed
- * @return {boolean}
+ * 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();
@@ -91,8 +92,17 @@ PublicKeyInput.prototype.isFullySigned = function () {
 // <=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;
 };

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

@@ -2,15 +2,15 @@
 
 var inherits = require('inherits');
 
-var $ = require('../../util/preconditions');
+var $ = require('../../util/preconditions.cjs');
 
-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');
+var Hash = require('../../crypto/hash.cjs');
+var Input = require('./input.cjs');
+var Output = require('../output.cjs');
+var Sighash = require('../sighash.cjs');
+var Script = require('../../script/index.cjs');
+var Signature = require('../../crypto/signature.cjs');
+var TransactionSignature = require('../signature.cjs');
 
 /**
  * Represents a special kind of input of PayToPublicKeyHash kind.
@@ -25,8 +25,8 @@ 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
+ * @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 (
@@ -60,14 +60,13 @@ PublicKeyHashInput.prototype.getSignatures = function (
   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
+ * 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');
@@ -109,8 +108,17 @@ PublicKeyHashInput.prototype.isFullySigned = function () {
 // 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;
 };

package/{lib/transaction/output.js → cjs/transaction/output.cjs}

@@ -1,17 +1,26 @@
 '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 _ = require('../util/_.cjs');
+var BN = require('../crypto/bn.cjs');
+var JSUtil = require('../util/js.cjs');
+var BufferWriter = require('../encoding/bufferwriter.cjs');
+var Varint = require('../encoding/varint.cjs');
+var Script = require('../script/index.cjs');
+var $ = require('../util/preconditions.cjs');
+var errors = require('../errors/index.cjs');
+var Hash = require('../crypto/hash.cjs')
 
 var MAX_SAFE_INTEGER = 0x1fffffffffffff;
 
+/**
+ * Represents a transaction output in the Bitcoin protocol.
+ * @constructor
+ * @param {Object} args - The arguments to create an Output.
+ * @param {number} args.satoshis - The amount in satoshis.
+ * @param {Buffer|string|Script} args.script - The output script (either as Buffer or hex string).
+ * @param {Buffer|string} [args.data] - Additional data associated with the output.
+ * @throws {TypeError} If arguments are invalid or unrecognized.
+ */
 function Output(args) {
   if (!(this instanceof Output)) {
     return new Output(args);
@@ -34,7 +43,11 @@ function Output(args) {
     throw new TypeError('Unrecognized argument for Output');
   }
 }
-
+/**
+ * Gets or sets the script associated with this Output instance.
+ * @memberof Output.prototype
+ * @name script
+ */
 Object.defineProperty(Output.prototype, 'script', {
   configurable: false,
   enumerable: true,
@@ -43,6 +56,12 @@ Object.defineProperty(Output.prototype, 'script', {
   },
 });
 
+/**
+ * Gets or sets the transaction output data.
+ * @memberof Output.prototype
+ * @name data
+ * @type {Buffer|string}
+ */
 Object.defineProperty(Output.prototype, 'data', {
   configurable: false,
   enumerable: true,
@@ -50,7 +69,12 @@ Object.defineProperty(Output.prototype, 'data', {
     return this._data;
   },
 });
-
+/**
+ * Gets the satoshis value of the Output instance.
+ * @memberof Output.prototype
+ * @name satoshis
+ * @type {BN|string|number}
+ */
 Object.defineProperty(Output.prototype, 'satoshis', {
   configurable: false,
   enumerable: true,
@@ -73,6 +97,11 @@ Object.defineProperty(Output.prototype, 'satoshis', {
   },
 });
 
+/**
+ * Checks if the satoshis value in this output is invalid.
+ * @returns {string|boolean} Returns an error message string if invalid (satoshis exceed max safe integer, 
+ *                           corrupted value, or negative), otherwise returns false.
+ */
 Output.prototype.invalidSatoshis = function () {
   if (this._satoshis > MAX_SAFE_INTEGER) {
     return 'transaction txout satoshis greater than max safe integer';
@@ -86,6 +115,12 @@ Output.prototype.invalidSatoshis = function () {
   return false;
 };
 
+/**
+ * Gets the satoshis value as a BN (BigNumber) instance.
+ * @memberof Output.prototype
+ * @name satoshisBN
+ * @type {BN}
+ */
 Object.defineProperty(Output.prototype, 'satoshisBN', {
   configurable: false,
   enumerable: true,
@@ -99,6 +134,11 @@ Object.defineProperty(Output.prototype, 'satoshisBN', {
   },
 });
 
+/**
+ * Converts the Output instance to a plain object representation.
+ * The resulting object includes satoshis, script (as hex string), and data (as hex string).
+ * @returns {Object} - An object with satoshis, script, and data properties.
+ */
 Output.prototype.toObject = Output.prototype.toJSON = function toObject() {
   var obj = {
     satoshis: this.satoshis,
@@ -108,6 +148,11 @@ Output.prototype.toObject = Output.prototype.toJSON = function toObject() {
   return obj;
 };
 
+/**
+ * Sets the output data.
+ * @param {Buffer|string} data - The data to set. Can be a Buffer or hex string.
+ * @throws {TypeError} If data is not a Buffer or valid hex string.
+ */
 Output.prototype.setData = function (data) {
   if (!data) {
     this._data = Buffer.from([])
@@ -122,10 +167,21 @@ Output.prototype.setData = function (data) {
   }
 }
 
+/**
+ * Creates an Output instance from a plain JavaScript object.
+ * @param {Object} data - The input object to convert to an Output
+ * @returns {Output} A new Output instance
+ * @static
+ */
 Output.fromObject = function (data) {
   return new Output(data);
 };
 
+/**
+ * Sets the script for this output from a buffer.
+ * @param {Buffer} buffer - The buffer containing the script data.
+ * @throws {errors.Script.InvalidBuffer} If the buffer is invalid.
+ */
 Output.prototype.setScriptFromBuffer = function (buffer) {
   try {
     this._script = Script.fromBuffer(buffer);
@@ -139,6 +195,12 @@ Output.prototype.setScriptFromBuffer = function (buffer) {
   }
 };
 
+/**
+ * Sets the script for this output.
+ * @param {Script|string|Buffer} script - The script to set, which can be a Script instance, hex string, or Buffer.
+ * @returns {Output} Returns the output instance for chaining.
+ * @throws {TypeError} Throws if the script type is invalid.
+ */
 Output.prototype.setScript = function (script) {
   if (script instanceof Script) {
     this._script = script;
@@ -154,6 +216,11 @@ Output.prototype.setScript = function (script) {
   return this;
 };
 
+/**
+ * Returns a human-readable string representation of the Output object.
+ * Format: '<Output (satoshis sats) scriptString>'
+ * @returns {string} Formatted string showing satoshis and script inspection result
+ */
 Output.prototype.inspect = function () {
   var scriptStr;
   if (this.script) {
@@ -162,6 +229,13 @@ Output.prototype.inspect = function () {
   return '<Output (' + this.satoshis + ' sats) ' + scriptStr + '>';
 };
 
+/**
+ * Creates an Output instance from a BufferReader.
+ * @param {BufferReader} br - The buffer reader containing output data
+ * @returns {Output} A new Output instance
+ * @throws {TypeError} If the buffer contains unrecognized output format
+ * @static
+ */
 Output.fromBufferReader = function (br) {
   var obj = {}
   obj.satoshis = br.readUInt64LEBN()
@@ -186,8 +260,14 @@ Output.fromBufferReader = function (br) {
   return new Output(obj)
 }
 
+/**
+ * Converts the Output instance to a buffer writer format.
+ * @param {boolean} hashScriptPubkey - If true, hashes script and data with SHA256; otherwise writes them directly.
+ * @param {BufferWriter} [writer] - Optional BufferWriter instance. If not provided, a new one is created.
+ * @returns {BufferWriter} The buffer writer containing the serialized output data.
+ */
 Output.prototype.toBufferWriter = function (hashScriptPubkey, writer) {
-    $.checkArgument(typeof hashScriptPubkey === 'boolean', 'hashScriptSig should be boolean')
+  $.checkArgument(typeof hashScriptPubkey === 'boolean', 'hashScriptSig should be boolean')
   if (!writer) {
     writer = new BufferWriter();
   }
@@ -208,13 +288,14 @@ Output.prototype.toBufferWriter = function (hashScriptPubkey, writer) {
   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.
+ * 8    value
+ * ???  script+data size (VARINT)
+ * script size
+ * data size
  * @returns {number} The total output size in bytes.
  */
 Output.prototype.getSize = function () {
@@ -224,6 +305,10 @@ Output.prototype.getSize = function () {
   return 8 + varintSize + scriptSize + dataSize
 };
 
+/**
+ * Creates a shallow clone of the Output instance.
+ * @returns {Output} A new Output instance with the same properties as the original.
+ */
 Output.prototype.clone = function () {
   return Output.fromObject(this.toObject());
 }

package/cjs/transaction/sighash.cjs

@@ -0,0 +1,187 @@
+'use strict'
+var Signature = require('../crypto/signature.cjs')
+var Script = require('../script/index.cjs')
+var Output = require('./output.cjs')
+var BufferReader = require('../encoding/bufferreader.cjs')
+var BufferWriter = require('../encoding/bufferwriter.cjs')
+var Hash = require('../crypto/hash.cjs')
+var ECDSA = require('../crypto/ecdsa.cjs')
+var $ = require('../util/preconditions.cjs')
+var _ = require('../util/_.cjs')
+
+var SIGHASH_SINGLE_BUG = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex')
+
+/**
+ * Represents a Sighash utility for cryptographic signature operations.
+ * @constructor
+ */
+function Sighash() {
+
+};
+
+/**
+ * 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)
+ *
+ */
+Sighash.sighashPreimage = function (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()
+}
+
+Sighash.getLowSSighashPreimage = function(tx, sigtype, inputIndex) {
+  var i = 0;
+  do {
+    var preimage = Sighash.sighashPreimage(tx, sigtype, inputIndex);
+
+    var sighash = Hash.sha256sha256(preimage);
+
+    if (_.isPositiveNumber(sighash.readUInt8()) && _.isPositiveNumber(sighash.readUInt8(31))) {
+      return preimage;
+    }
+
+    tx.nLockTime++;
+  } while (i < Number.MAX_SAFE_INTEGER);
+}
+
+
+/**
+ * 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
+ *
+ */
+Sighash.sighash = function (transaction, sighashType, inputNumber) {
+  var preimage = Sighash.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}
+ */
+Sighash.sign = function (transaction, privateKey, sighashType, inputIndex) {
+  var hashbuf = Sighash.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}
+ */
+Sighash.verify = function (transaction, signature, publicKey, inputIndex) {
+  $.checkArgument(!_.isUndefined(transaction))
+  $.checkArgument(!_.isUndefined(signature) && !_.isUndefined(signature.nhashtype))
+  var hashbuf = Sighash.sighash(transaction, signature.nhashtype, inputIndex)
+  return ECDSA.verify(hashbuf, signature, publicKey, 'little')
+}
+
+/**
+ * @namespace Signing
+ */
+module.exports = Sighash

package/{lib/transaction/signature.js → cjs/transaction/signature.cjs}

@@ -1,13 +1,13 @@
 'use strict';
 
-var _ = require('../util/_');
-var $ = require('../util/preconditions');
+var _ = require('../util/_.cjs');
+var $ = require('../util/preconditions.cjs');
 var inherits = require('inherits');
-var JSUtil = require('../util/js');
+var JSUtil = require('../util/js.cjs');
 
-var PublicKey = require('../publickey');
-var errors = require('../errors');
-var Signature = require('../crypto/signature');
+var PublicKey = require('../publickey.cjs');
+var errors = require('../errors/index.cjs');
+var Signature = require('../crypto/signature.cjs');
 
 /**
  * @desc
@@ -30,6 +30,18 @@ function TransactionSignature(arg) {
 }
 inherits(TransactionSignature, Signature);
 
+/**
+ * Initializes the TransactionSignature instance from a plain object.
+ * Validates and converts object properties into appropriate types.
+ * @param {Object} arg - The source object containing signature data
+ * @param {Buffer|string} arg.prevTxId - Previous transaction ID (buffer or hex string)
+ * @param {number} arg.outputIndex - Output index
+ * @param {number} arg.inputIndex - Input index
+ * @param {Signature|Buffer|string} arg.signature - Signature in various formats
+ * @param {number} arg.sigtype - Signature type
+ * @returns {TransactionSignature} Returns the instance for chaining
+ * @private
+ */
 TransactionSignature.prototype._fromObject = function (arg) {
   this._checkObjectArgs(arg);
   this.publicKey = new PublicKey(arg.publicKey);
@@ -46,6 +58,18 @@ TransactionSignature.prototype._fromObject = function (arg) {
   return this;
 };
 
+/**
+ * Validates the arguments for a transaction signature object.
+ * @private
+ * @param {Object} arg - The signature object to validate
+ * @param {PublicKey} arg.publicKey - The public key
+ * @param {number} arg.inputIndex - The input index (must be a number)
+ * @param {number} arg.outputIndex - The output index (must be a number)
+ * @param {Buffer|string|Signature} arg.signature - The signature (must be Buffer, hex string, or Signature)
+ * @param {Buffer|string} arg.prevTxId - Previous transaction ID (must be Buffer or hex string)
+ * @param {number} arg.sigtype - Signature type (must be a number)
+ * @throws {Error} If any argument fails validation
+ */
 TransactionSignature.prototype._checkObjectArgs = function (arg) {
   $.checkArgument(PublicKey(arg.publicKey), 'publicKey');
   $.checkArgument(!_.isUndefined(arg.inputIndex), 'inputIndex');