@opcat-labs/opcat 1.0.1 → 1.0.3

package/cjs/transaction/transaction.cjs

@@ -0,0 +1,2000 @@
+'use strict';
+
+var _ = require('../util/_.cjs');
+var $ = require('../util/preconditions.cjs');
+
+var errors = require('../errors/index.cjs');
+var JSUtil = require('../util/js.cjs');
+var BufferReader = require('../encoding/bufferreader.cjs');
+var BufferWriter = require('../encoding/bufferwriter.cjs');
+var Varint = require('../encoding/varint.cjs');
+var Hash = require('../crypto/hash.cjs');
+var Signature = require('../crypto/signature.cjs');
+var TransactionSignature = require('./signature.cjs');
+var Sighash = require('./sighash.cjs');
+
+var Address = require('../address.cjs');
+var UnspentOutput = require('./unspentoutput.cjs');
+var Input = require('./input/index.cjs');
+var PublicKeyHashInput = Input.PublicKeyHash;
+var PublicKeyInput = Input.PublicKey;
+var Output = require('./output.cjs');
+var Script = require('../script/index.cjs');
+var PrivateKey = require('../privatekey.cjs');
+var BN = require('../crypto/bn.cjs');
+
+/**
+ * Represents a transaction, a set of inputs and outputs to change ownership of tokens
+ * @constructor
+ * @param {string|Buffer|Object|Transaction} [serialized] - Optional serialized data to initialize the transaction.
+ * Can be a hex string, Buffer, plain object, or another Transaction instance.
+ * @throws {errors.InvalidArgument} If invalid serialization format is provided.
+ * @property {Array} inputs - Transaction input objects.
+ * @property {Array} outputs - Transaction output objects.
+ * @property {boolean} sealed - Indicates if transaction is finalized.
+ */
+function Transaction(serialized) {
+  if (!(this instanceof Transaction)) {
+    return new Transaction(serialized);
+  }
+  this.inputs = [];
+  this.outputs = [];
+  this._inputAmount = undefined;
+  this._outputAmount = undefined;
+  this._inputsMap = new Map();
+  this._outputsMap = new Map();
+  this._privateKey = undefined;
+  this._sigType = undefined;
+  this.sealed = false;
+  if (serialized) {
+    if (serialized instanceof Transaction) {
+      return Transaction.shallowCopy(serialized);
+    } else if (JSUtil.isHexa(serialized)) {
+      this.fromString(serialized);
+    } else if (Buffer.isBuffer(serialized)) {
+      this.fromBuffer(serialized);
+    } else if (_.isObject(serialized)) {
+      this.fromObject(serialized);
+    } else {
+      throw new errors.InvalidArgument(
+        'Must provide an object or string to deserialize a transaction',
+      );
+    }
+  } else {
+    this._newTransaction();
+  }
+}
+
+var CURRENT_VERSION = 1;
+var DEFAULT_NLOCKTIME = 0;
+
+
+/**
+ * The minimum amount (in satoshis) considered non-dust in a transaction.
+ * @type {number}
+ * @default 1
+ */
+Transaction.DUST_AMOUNT = 1;
+
+
+/**
+ * Margin of error to allow fees in the vecinity of the expected value but doesn't allow a big difference
+ * @type {number}
+ * @default 150
+ */
+Transaction.FEE_SECURITY_MARGIN = 150;
+
+// max amount of satoshis in circulation
+/**
+ * The maximum amount of money (in satoshis) that can be transacted in a single transaction.
+ * This follows Bitcoin's 21 million coin limit (21000000 * 1e8 satoshis).
+ * @type {number}
+ * @default 2100000000000000
+ */
+Transaction.MAX_MONEY = 21000000 * 1e8;
+
+/**
+ * The maximum block height value allowed for nLockTime in a transaction.
+ * Transactions with nLockTime above this value are interpreted as timestamp-based.
+ * @type {number}
+ * @default 500000000
+ */
+Transaction.NLOCKTIME_BLOCKHEIGHT_LIMIT = 5e8;
+
+
+/**
+ * The maximum value allowed for the nLockTime field in a transaction (2^32 - 1).
+ * @type {number}
+ * @default 4294967295
+ */
+Transaction.NLOCKTIME_MAX_VALUE = 4294967295;
+
+/**
+ * The fee per kilobyte (KB) for transactions, in satoshis.
+ * @type {number}
+ * @default 1
+ */
+Transaction.FEE_PER_KB = 1;
+
+
+
+/**
+ * a dummy privatekey
+ * @type {PrivateKey}
+ */
+Transaction.DUMMY_PRIVATEKEY = PrivateKey.fromWIF(
+  'cQ3nCBQB9RsFSyjNQM15NQLVpXXMtWh9PUyeFz5KxLJCHsuRH2Su',
+);
+
+
+/**
+ * Creates a Transaction instance from a raw hexadecimal string.
+ * @param {string} rawHex - The hexadecimal string representation of the transaction.
+ * @returns {Transaction} A new Transaction instance populated from the input string.
+ */
+Transaction.fromString = function (rawHex) {
+  return new Transaction().fromString(rawHex)
+}
+/**
+ * Creates a Transaction instance from a buffer.
+ * @param {Buffer} buffer - The input buffer containing transaction data.
+ * @returns {Transaction} A new Transaction instance populated from the buffer.
+ */
+Transaction.fromBuffer = function (buffer) {
+  return new Transaction().fromBuffer(buffer)
+}
+/**
+ * Creates a Transaction instance from a plain object.
+ * @param {Object} obj - The plain object to convert to a Transaction.
+ * @returns {Transaction} A new Transaction instance populated from the object.
+ */
+Transaction.fromObject = function (obj) {
+  return new Transaction().fromObject(obj)
+}
+
+
+/**
+ * Create a 'shallow' copy of the transaction, by serializing and deserializing
+ * it dropping any additional information that inputs and outputs may have hold
+ * @param {Transaction} transaction - The transaction to copy.
+ * @returns {Transaction} A new Transaction instance with the same data.
+ */
+Transaction.shallowCopy = function (transaction) {
+  var copy = new Transaction(transaction.toBuffer());
+  return copy;
+};
+
+var hashProperty = {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    this._hash = new BufferReader(this._getHash()).readReverse().toString('hex');
+    return this._hash;
+  },
+};
+/**
+ * The unique identifier hash of the transaction.
+ * @name Transaction.prototype.hash
+ * @memberof Transaction
+ * @instance
+ * @type {string}
+ */
+Object.defineProperty(Transaction.prototype, 'hash', hashProperty);
+/**
+ * The unique identifier hash of the transaction.
+ * @name Transaction.prototype.id
+ * @memberof Transaction
+ * @instance
+ * @type {string}
+ */
+Object.defineProperty(Transaction.prototype, 'id', hashProperty);
+
+/**
+ * Gets the inputs amount for the transaction.
+ * @name Transaction.prototype.inputAmount
+ * @memberof Transaction
+ * @type {number}
+ */
+Object.defineProperty(Transaction.prototype, 'inputAmount', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    return this._getInputAmount();
+  },
+});
+
+/**
+ * Gets the outputs amount for the transaction.
+ * @name Transaction.prototype.outputAmount
+ * @memberof Transaction
+ * @type {number}
+ */
+Object.defineProperty(Transaction.prototype, 'outputAmount', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+  return this._getOutputAmount();
+  },
+});
+
+/**
+ * Retrieve the little endian hash of the transaction (used for serialization)
+ * @return {Buffer}
+ * @private
+ */
+Transaction.prototype._getHash = function () {
+  return Hash.sha256sha256(this.toBufferWriter(true).toBuffer());
+};
+
+/**
+ * Retrieve a hexa string that can be used with bitcoind's CLI interface
+ * (decoderawtransaction, sendrawtransaction)
+ *
+ * @param {Object|boolean=} unsafe if true, skip all tests. if it's an object,
+ *   it's expected to contain a set of flags to skip certain tests:
+ * * `disableAll`: disable all checks
+ * * `disableLargeFees`: disable checking for fees that are too large
+ * * `disableIsFullySigned`: disable checking if all inputs are fully signed
+ * * `disableDustOutputs`: disable checking if there are no outputs that are dust amounts
+ * * `disableMoreOutputThanInput`: disable checking if the transaction spends more bitcoins than the sum of the input amounts
+ * @return {string}
+ */
+Transaction.prototype.serialize = function (unsafe) {
+  if (unsafe === true || (unsafe && unsafe.disableAll)) {
+    return this.uncheckedSerialize();
+  } else {
+    return this.checkedSerialize(unsafe);
+  }
+};
+
+/**
+ * Creates a deep clone of the Transaction instance.
+ * @returns {Transaction} A new Transaction instance with cloned inputs.
+ */
+Transaction.prototype.clone = function () {
+  const tx = Transaction.fromString(this.uncheckedSerialize());
+  this.inputs.forEach((input, index) => {
+    if(input.output) {
+      tx.inputs[index].output = input.output.clone();
+    }
+  });
+  return tx;
+};
+
+/**
+ * Serializes the transaction to a hexadecimal string.
+ * This method is aliased as `toString()` and `toHex()` for convenience.
+ * @returns {string} Hexadecimal representation of the transaction.
+ */
+Transaction.prototype.uncheckedSerialize = Transaction.prototype.toString = Transaction.prototype.toHex = function () {
+  return this.toBuffer().toString('hex');
+};
+
+/**
+ * Retrieve a hexa string that can be used with bitcoind's CLI interface
+ * (decoderawtransaction, sendrawtransaction)
+ *
+ * @param {Object} opts allows to skip certain tests. {@see Transaction#serialize}
+ * @return {string}
+ */
+Transaction.prototype.checkedSerialize = function (opts) {
+  var serializationError = this.getSerializationError(opts);
+  if (serializationError) {
+    serializationError.message +=
+      ' - For more information please see: ' + 'https://github.com/OPCAT-Labs/ts-tools';
+    throw serializationError;
+  }
+  return this.uncheckedSerialize();
+};
+
+/**
+ * Checks if any output in the transaction has invalid satoshis.
+ * @returns {boolean} True if at least one output has invalid satoshis, false otherwise.
+ */
+Transaction.prototype.invalidSatoshis = function () {
+  var invalid = false;
+  for (var i = 0; i < this.outputs.length; i++) {
+    if (this.outputs[i].invalidSatoshis()) {
+      invalid = true;
+    }
+  }
+  return invalid;
+};
+
+/**
+ * Retrieve a possible error that could appear when trying to serialize and
+ * broadcast this transaction.
+ *
+ * @param {Object} opts allows to skip certain tests. {@see Transaction#serialize}
+ * @return {opcat.Error}
+ */
+Transaction.prototype.getSerializationError = function (opts) {
+  opts = opts || {};
+
+  if (this.invalidSatoshis()) {
+    return new errors.Transaction.InvalidSatoshis();
+  }
+
+  var unspent = this.getUnspentValue();
+  var unspentError;
+  if (unspent < 0) {
+    if (!opts.disableMoreOutputThanInput) {
+      unspentError = new errors.Transaction.InvalidOutputAmountSum();
+    }
+  } else {
+    unspentError = this._hasFeeError(opts, unspent);
+  }
+
+  return unspentError || this._hasDustOutputs(opts) || this._isMissingSignatures(opts);
+};
+
+/**
+ * Checks for fee-related errors in a transaction.
+ * 
+ * @param {Object} opts - Transaction options
+ * @param {number} unspent - The unspent amount to be used as fee
+ * @returns {errors.Transaction.FeeError.Different|errors.Transaction.ChangeAddressMissing|errors.Transaction.FeeError.TooLarge|undefined}
+ * Returns a fee error if:
+ * - Specified fee doesn't match unspent amount
+ * - Fee is too large and no change address is provided (when large fees are enabled)
+ * - Fee exceeds security margin (when large fees are enabled)
+ * Otherwise returns undefined if no errors are found.
+ * @private
+ */
+Transaction.prototype._hasFeeError = function (opts, unspent) {
+  if (!_.isUndefined(this._fee) && this._fee !== unspent) {
+    return new errors.Transaction.FeeError.Different(
+      'Unspent value is ' + unspent + ' but specified fee is ' + this._fee,
+    );
+  }
+
+  if (!opts.disableLargeFees) {
+    var maximumFee = Math.floor(Transaction.FEE_SECURITY_MARGIN * this._estimateFee());
+    if (unspent > maximumFee) {
+      if (this._missingChange()) {
+        return new errors.Transaction.ChangeAddressMissing(
+          'Fee is too large and no change address was provided',
+        );
+      }
+      return new errors.Transaction.FeeError.TooLarge(
+        'expected less than ' + maximumFee + ' but got ' + unspent,
+      );
+    }
+  }
+};
+
+/**
+ * Checks if the transaction is missing a change script.
+ * @returns {boolean} True if change script is missing, false otherwise.
+ * @private
+ */
+Transaction.prototype._missingChange = function () {
+  return !this._changeScript;
+};
+
+/**
+ * Checks if the transaction contains any dust outputs (outputs below the dust limit).
+ * @param {Object} opts - Options object.
+ * @param {boolean} [opts.disableDustOutputs] - If true, skips dust output checking.
+ * @returns {errors.Transaction.DustOutputs|undefined} Returns DustOutputs error if dust outputs are found, otherwise undefined.
+ * @private
+ */
+Transaction.prototype._hasDustOutputs = function (opts) {
+  if (opts.disableDustOutputs) {
+    return;
+  }
+  var index, output;
+  for (index in this.outputs) {
+    output = this.outputs[index];
+    if (
+      output.satoshis < Transaction.DUST_AMOUNT &&
+      !output.script.isDataOut() &&
+      !output.script.isSafeDataOut()
+    ) {
+      return new errors.Transaction.DustOutputs();
+    }
+  }
+};
+
+/**
+ * Checks if the transaction is missing signatures.
+ * @param {Object} opts - Options object.
+ * @param {boolean} [opts.disableIsFullySigned] - If true, skips the check.
+ * @returns {errors.Transaction.MissingSignatures|undefined} Returns MissingSignatures error if not fully signed, otherwise undefined.
+ */
+Transaction.prototype._isMissingSignatures = function (opts) {
+  if (opts.disableIsFullySigned) {
+    return;
+  }
+  if (!this.isFullySigned()) {
+    return new errors.Transaction.MissingSignatures();
+  }
+};
+
+/**
+ * Returns a string representation of the Transaction object for debugging/inspection.
+ * The format is: '<Transaction: [serializedData]>' where serializedData comes from uncheckedSerialize().
+ * @returns {string} Formatted transaction inspection string.
+ */
+Transaction.prototype.inspect = function () {
+  return '<Transaction: ' + this.uncheckedSerialize() + '>';
+};
+
+/**
+ * Converts the transaction to a Buffer.
+ * @returns {Buffer} The serialized transaction as a Buffer.
+ */
+Transaction.prototype.toBuffer = function () {
+  var writer = new BufferWriter();
+  return this.toBufferWriter(false, writer).toBuffer();
+};
+
+
+/**
+ * Calculates the double SHA-256 hash of the transaction preimage for signature verification.
+ * The resulting hash is returned in reverse byte order (little-endian).
+ * 
+ * @param {number} inputIndex - Index of the input being signed
+ * @param {number} hashType - SIGHASH type flag
+ * @returns {Buffer} The hash result in little-endian format
+ */
+Transaction.prototype.hashForSignature = function (inputIndex, hashType) {
+  var preimage = this.getPreimage(inputIndex, hashType);
+  var ret = Hash.sha256sha256(preimage)
+  return new BufferReader(ret).readReverse()
+}
+
+/**
+ * Converts the transaction to a hash preimage by serializing it into a buffer.
+ * @returns {Buffer} The serialized transaction data as a buffer.
+ */
+Transaction.prototype.toTxHashPreimage = function () {
+  var writer = new BufferWriter();
+  return this.toBufferWriter(true, writer).toBuffer();
+}
+
+
+/**
+ * Serializes the transaction to a BufferWriter.
+ * @param {boolean} forTxHash - Whether to serialize for transaction hash calculation (excludes some fields)
+ * @param {BufferWriter} [writer] - Optional BufferWriter instance to write to
+ * @returns {BufferWriter} The BufferWriter containing serialized transaction data
+ */
+Transaction.prototype.toBufferWriter = function (forTxHash, writer) {
+  $.checkArgument(typeof forTxHash === 'boolean', 'forTxHash parameter must be a boolean');
+  writer = writer || new BufferWriter();
+  writer.writeUInt32LE(this.version);
+  writer.writeVarintNum(this.inputs.length);
+  _.each(this.inputs, function (input) {
+    input.toBufferWriter(forTxHash, writer);
+  });
+  writer.writeVarintNum(this.outputs.length);
+  _.each(this.outputs, function (output) {
+    output.toBufferWriter(forTxHash, writer);
+  });
+  writer.writeUInt32LE(this.nLockTime);
+  return writer;
+};
+
+/**
+ * Initializes the transaction from a buffer.
+ * @param {Buffer} buffer - The buffer containing transaction data.
+ * @returns {Transaction} The transaction instance.
+ */
+Transaction.prototype.fromBuffer = function (buffer) {
+  var reader = new BufferReader(buffer);
+  return this.fromBufferReader(reader);
+};
+
+/**
+ * Reads transaction data from a buffer reader and populates the transaction instance.
+ * @param {BufferReader} reader - The buffer reader containing transaction data.
+ * @returns {Transaction} The transaction instance with populated data.
+ * @throws {Error} If no transaction data is received (reader is finished).
+ */
+Transaction.prototype.fromBufferReader = function (reader) {
+  $.checkArgument(!reader.finished(), 'No transaction data received');
+  var i, sizeTxIns, sizeTxOuts;
+
+  this.version = reader.readInt32LE();
+  sizeTxIns = reader.readVarintNum();
+  for (i = 0; i < sizeTxIns; i++) {
+    var input = Input.fromBufferReader(reader);
+    this.inputs.push(input);
+  }
+  sizeTxOuts = reader.readVarintNum();
+  for (i = 0; i < sizeTxOuts; i++) {
+    this.outputs.push(Output.fromBufferReader(reader));
+  }
+  this.nLockTime = reader.readUInt32LE();
+  return this;
+};
+
+/**
+ * Converts the Transaction object to a plain JavaScript object (POJO) for serialization.
+ * Includes transaction details like hash, version, inputs, outputs, and lock time.
+ * Optionally includes change script, change address, change index, and fee if they are defined.
+ * @returns {Object} A plain object representation of the transaction.
+ */
+Transaction.prototype.toObject = Transaction.prototype.toJSON = function toObject() {
+  var inputs = [];
+  this.inputs.forEach(function (input) {
+    inputs.push(input.toObject());
+  });
+  var outputs = [];
+  this.outputs.forEach(function (output) {
+    outputs.push(output.toObject());
+  });
+  var obj = {
+    hash: this.hash,
+    version: this.version,
+    inputs: inputs,
+    outputs: outputs,
+    nLockTime: this.nLockTime,
+  };
+  if (this._changeScript) {
+    obj.changeScript = this._changeScript.toString();
+  }
+
+  if (this._changeScript) {
+    obj.changeAddress = this._changeAddress.toString();
+  }
+
+  if (!_.isUndefined(this._changeIndex)) {
+    obj.changeIndex = this._changeIndex;
+  }
+  if (!_.isUndefined(this._fee)) {
+    obj.fee = this._fee;
+  }
+  return obj;
+};
+
+/**
+ * Creates a Transaction instance from a plain object or another Transaction.
+ * Handles conversion of inputs/outputs and other transaction properties.
+ * 
+ * @param {Object|Transaction} arg - Either a transaction object or Transaction instance
+ * @returns {Transaction} The populated Transaction instance
+ * @throws {Error} If argument is not an object or Transaction instance
+ */
+Transaction.prototype.fromObject = function fromObject(arg) {
+  $.checkArgument(_.isObject(arg) || arg instanceof Transaction);
+  var self = this;
+  var transaction;
+  if (arg instanceof Transaction) {
+    transaction = transaction.toObject();
+  } else {
+    transaction = arg;
+  }
+  _.each(transaction.inputs, function (input) {
+    if (!input.output || !input.output.script) {
+      self.uncheckedAddInput(new Input(input));
+      return;
+    }
+    var script = new Script(input.output.script);
+    var txin;
+    if (script.isPublicKeyHashOut()) {
+      txin = new Input.PublicKeyHash(input);
+    } else if (script.isPublicKeyOut()) {
+      txin = new Input.PublicKey(input);
+    } else {
+      txin = new Input(input)
+    }
+    self.addInput(txin);
+  });
+  _.each(transaction.outputs, function (output) {
+    self.addOutput(new Output(output));
+  });
+  if (transaction.changeIndex) {
+    this._changeIndex = transaction.changeIndex;
+  }
+  if (transaction.changeScript) {
+    this._changeScript = new Script(transaction.changeScript);
+  }
+  if (transaction.changeAddress) {
+    this._changeAddress = Address.fromString(transaction.changeAddress);
+  }
+  if (transaction.changeData) {
+    this._changeData = transaction.changeData;
+  }
+  if (transaction.fee) {
+    this._fee = transaction.fee;
+  }
+  this.nLockTime = transaction.nLockTime;
+  this.version = transaction.version;
+  this._checkConsistency(arg);
+  return this;
+};
+
+/**
+ * Checks transaction consistency by validating:
+ * - Change output script and address (if change index is set)
+ * - Transaction hash (if provided in arg)
+ * @param {Object} [arg] - Optional argument containing expected hash
+ * @throws {Error} If any consistency check fails
+ * @private
+ */
+Transaction.prototype._checkConsistency = function (arg) {
+  if (!_.isUndefined(this._changeIndex)) {
+    $.checkState(this._changeScript, 'Change script is expected.');
+    $.checkState(this._changeAddress, 'Change address is expected.');
+    $.checkState(this.outputs[this._changeIndex], 'Change index points to undefined output.');
+    $.checkState(
+      this.outputs[this._changeIndex].script.toString() === this._changeScript.toString(),
+      'Change output has an unexpected script.',
+    );
+  }
+  if (arg && arg.hash) {
+    $.checkState(arg.hash === this.hash, 'Hash in object does not match transaction hash.');
+  }
+};
+
+
+/**
+ * Sets nLockTime so that transaction is not valid until the desired date(a
+ * timestamp in seconds since UNIX epoch is also accepted)
+ * @param {number|Date} time - The lock time as a timestamp (number) or Date object.
+ * @throws {Transaction.LockTimeTooEarly} If the time is a number below NLOCKTIME_BLOCKHEIGHT_LIMIT.
+ * @returns {Transaction} The transaction instance for chaining.
+ */
+Transaction.prototype.lockUntilDate = function (time) {
+  $.checkArgument(time);
+  if (_.isNumber(time) && time < Transaction.NLOCKTIME_BLOCKHEIGHT_LIMIT) {
+    throw new errors.Transaction.LockTimeTooEarly();
+  }
+  if (_.isDate(time)) {
+    time = time.getTime() / 1000;
+  }
+
+  for (var i = 0; i < this.inputs.length; i++) {
+    if (this.inputs[i].sequenceNumber === Input.DEFAULT_SEQNUMBER) {
+      this.inputs[i].sequenceNumber = Input.DEFAULT_LOCKTIME_SEQNUMBER;
+    }
+  }
+
+  this.nLockTime = time;
+  return this;
+};
+
+
+/**
+ * Sets the transaction's lock time to a specific block height.
+ * Validates the height is within allowed bounds (0 <= height < NLOCKTIME_BLOCKHEIGHT_LIMIT).
+ * Updates sequence numbers of inputs to enable lock time if using default sequence.
+ * @param {number} height - The block height to lock until (must be non-negative and below limit)
+ * @returns {Transaction} Returns the transaction instance for chaining
+ * @throws {Transaction.BlockHeightTooHigh} If height exceeds block height limit
+ * @throws {Transaction.NLockTimeOutOfRange} If height is negative
+ */
+Transaction.prototype.lockUntilBlockHeight = function (height) {
+  $.checkArgument(_.isNumber(height));
+  if (height >= Transaction.NLOCKTIME_BLOCKHEIGHT_LIMIT) {
+    throw new errors.Transaction.BlockHeightTooHigh();
+  }
+  if (height < 0) {
+    throw new errors.Transaction.NLockTimeOutOfRange();
+  }
+
+  for (var i = 0; i < this.inputs.length; i++) {
+    if (this.inputs[i].sequenceNumber === Input.DEFAULT_SEQNUMBER) {
+      this.inputs[i].sequenceNumber = Input.DEFAULT_LOCKTIME_SEQNUMBER;
+    }
+  }
+
+  this.nLockTime = height;
+  return this;
+};
+
+/**
+ *  Returns a semantic version of the transaction's nLockTime.
+ *  @return {Number|Date}
+ *  If nLockTime is 0, it returns null,
+ *  if it is < 500000000, it returns a block height (number)
+ *  else it returns a Date object.
+ */
+Transaction.prototype.getLockTime = function () {
+  if (!this.nLockTime) {
+    return null;
+  }
+  if (this.nLockTime < Transaction.NLOCKTIME_BLOCKHEIGHT_LIMIT) {
+    return this.nLockTime;
+  }
+  return new Date(1000 * this.nLockTime);
+};
+
+/**
+ * Converts a hex string into a transaction buffer and initializes the transaction.
+ * @param {string} string - Hex string representation of the transaction data.
+ * @returns {Transaction} The transaction instance initialized from the hex string.
+ */
+Transaction.prototype.fromString = function (string) {
+  return this.fromBuffer(Buffer.from(string, 'hex'));
+};
+
+/**
+ * Initializes a new transaction with default values.
+ * Sets the version to CURRENT_VERSION and nLockTime to DEFAULT_NLOCKTIME.
+ * @private
+ */
+Transaction.prototype._newTransaction = function () {
+  this.version = CURRENT_VERSION;
+  this.nLockTime = DEFAULT_NLOCKTIME;
+};
+
+/* Transaction creation interface */
+
+/**
+ * @typedef {Object} Transaction~fromObject
+ * @property {string} prevTxId
+ * @property {number} outputIndex
+ * @property {(Buffer|string|Script)} script
+ * @property {number} satoshis
+ */
+
+/**
+ * Add an input to this transaction. This is a high level interface
+ * to add an input, for more control, use @{link Transaction#addInput}.
+ *
+ * Can receive, as output information, the output of bitcoind's `listunspent` command,
+ * and a slightly fancier format recognized by opcat:
+ *
+ * ```
+ * {
+ *  address: 'mszYqVnqKoQx4jcTdJXxwKAissE3Jbrrc1',
+ *  txId: 'a477af6b2667c29670467e4e0728b685ee07b240235771862318e29ddbe58458',
+ *  outputIndex: 0,
+ *  script: Script.empty(),
+ *  satoshis: 1020000
+ * }
+ * ```
+ * Where `address` can be either a string or a opcat Address object. The
+ * same is true for `script`, which can be a string or a opcat Script.
+ *
+ * Beware that this resets all the signatures for inputs (in further versions,
+ * SIGHASH_SINGLE or SIGHASH_NONE signatures will not be reset).
+ *
+ * @example
+ * ```javascript
+ * var transaction = new Transaction();
+ *
+ * // From a pay to public key hash output from bitcoind's listunspent
+ * transaction.from({'txid': '0000...', vout: 0, amount: 0.1, scriptPubKey: 'OP_DUP ...'});
+ *
+ * // From a pay to public key hash output
+ * transaction.from({'txId': '0000...', outputIndex: 0, satoshis: 1000, script: 'OP_DUP ...'});
+ *
+ * ```
+ *
+ * @param {(Array.<Transaction~fromObject>|Transaction~fromObject)} utxo
+ * @param {Array=} pubkeys
+ * @param {number=} threshold
+ * @returns {Transaction} The transaction instance for chaining.
+ */
+Transaction.prototype.from = function (utxo) {
+  if (_.isArray(utxo)) {
+    var self = this;
+    _.each(utxo, function (utxo) {
+      self.from(utxo);
+    });
+    return this;
+  }
+  var exists = _.some(this.inputs, function (input) {
+    // TODO: Maybe prevTxId should be a string? Or defined as read only property?
+    return input.prevTxId.toString('hex') === utxo.txId && input.outputIndex === utxo.outputIndex;
+  });
+  if (exists) {
+    return this;
+  }
+  this._fromUTXO(utxo);
+  return this;
+};
+
+/**
+ * Adds an input to the transaction from a UTXO (Unspent Transaction Output).
+ * Determines the appropriate input type (PublicKeyHashInput, PublicKeyInput, or generic Input)
+ * based on the UTXO's script type.
+ * @param {Object} utxo - The UTXO to create input from
+ * @param {Script} utxo.script - The output script
+ * @param {number} utxo.satoshis - The output amount in satoshis
+ * @param {Buffer} [utxo.data] - Optional output data
+ * @param {string} utxo.txId - The previous transaction ID
+ * @param {number} utxo.outputIndex - The output index in previous transaction
+ * @private
+ */
+Transaction.prototype._fromUTXO = function (utxo) {
+  var Clazz;
+  utxo = new UnspentOutput(utxo);
+  if (utxo.script.isPublicKeyHashOut()) {
+    Clazz = PublicKeyHashInput;
+  } else if (utxo.script.isPublicKeyOut()) {
+    Clazz = PublicKeyInput;
+  } else {
+    Clazz = Input;
+  }
+  this.addInput(
+    new Clazz({
+      output: new Output({
+        script: utxo.script,
+        satoshis: utxo.satoshis,
+        data: utxo.data || Buffer.from([]),
+      }),
+      prevTxId: utxo.txId,
+      outputIndex: utxo.outputIndex,
+      script: Script.empty(),
+    }),
+  );
+};
+
+
+/**
+ * Add an input to this transaction. The input must be an instance of the `Input` class.
+ * It should have information about the Output that it's spending, but if it's not already
+ * set, three additional parameters, `outputScript`, `satoshis` and `data` can be provided.
+ * @param {Input} input - The input to add
+ * @param {Script|string} [outputScript] - The output script (required if input doesn't have output)
+ * @param {number} [satoshis] - The satoshis amount (required if input doesn't have output)
+ * @param {Buffer|string} [data] - Additional data for the output
+ * @returns {Transaction} The transaction instance for chaining
+ * @throws {errors.Transaction.NeedMoreInfo} If input has no output and missing required params
+ */
+Transaction.prototype.addInput = function (input, outputScript, satoshis, data) {
+  $.checkArgumentType(input, Input, 'input');
+  if (!input.output && (_.isUndefined(outputScript) || _.isUndefined(satoshis))) {
+    throw new errors.Transaction.NeedMoreInfo(
+      'Need information about the UTXO script and satoshis',
+    );
+  }
+  if (!input.output && outputScript && !_.isUndefined(satoshis)) {
+    outputScript = outputScript instanceof Script ? outputScript : new Script(outputScript);
+    $.checkArgumentType(satoshis, 'number', 'satoshis');
+
+    input.output = new Output({
+      script: outputScript,
+      satoshis: satoshis,
+      data: data,
+    });
+  }
+  return this.uncheckedAddInput(input);
+};
+
+/**
+ * Add an input to this transaction, without checking that the input has information about
+ * the output that it's spending.
+ *
+ * @param {Input} input
+ * @return Transaction this, for chaining
+ */
+Transaction.prototype.uncheckedAddInput = function (input) {
+  $.checkArgumentType(input, Input, 'input');
+  this.inputs.push(input);
+  this._inputAmount = undefined;
+  this._updateChangeOutput();
+  return this;
+};
+
+/**
+ * Returns true if the transaction has enough info on all inputs to be correctly validated
+ *
+ * @return {boolean}
+ */
+Transaction.prototype.hasAllUtxoInfo = function () {
+  return _.every(
+    this.inputs.map(function (input) {
+      return !!input.output;
+    }),
+  );
+};
+
+/**
+ * Manually set the fee for this transaction. Beware that this resets all the signatures
+ * for inputs (in further versions, SIGHASH_SINGLE or SIGHASH_NONE signatures will not
+ * be reset).
+ *
+ * @param {number} amount satoshis to be sent
+ * @return {Transaction} this, for chaining
+ */
+Transaction.prototype.fee = function (amount) {
+  $.checkArgument(_.isNumber(amount), 'amount must be a number');
+  this._fee = amount;
+  this._updateChangeOutput();
+  return this;
+};
+
+/**
+ * Manually set the fee per KB for this transaction. Beware that this resets all the signatures
+ * for inputs (in further versions, SIGHASH_SINGLE or SIGHASH_NONE signatures will not
+ * be reset).
+ *
+ * @param {number} amount satoshis per KB to be sent
+ * @return {Transaction} this, for chaining
+ */
+Transaction.prototype.feePerKb = function (amount) {
+  $.checkArgument(_.isNumber(amount), 'amount must be a number');
+  this._feePerKb = amount;
+  this._updateChangeOutput();
+  return this;
+};
+
+/* Output management */
+
+/**
+ * Set the change address for this transaction
+ *
+ * Beware that this resets all the signatures for inputs (in further versions,
+ * SIGHASH_SINGLE or SIGHASH_NONE signatures will not be reset).
+ *
+ * @param {Address} address An address for change to be sent to.
+ * @param {Buffer|string} data The data to be stored in the change output.
+ * @return {Transaction} this, for chaining
+ */
+Transaction.prototype.change = function (address, data) {
+  $.checkArgument(address, 'address is required');
+  this._changeScript = Script.fromAddress(address);
+  this._changeAddress = Address(address);
+  if (data) {
+    this._changeData = data
+  }
+  this._updateChangeOutput();
+  return this;
+};
+
+
+/**
+ * Gets the change output from the transaction outputs.
+ * @returns {Output|null} The change output object if defined, otherwise null.
+ */
+Transaction.prototype.getChangeOutput = function () {
+  if (!_.isUndefined(this._changeIndex)) {
+    return this.outputs[this._changeIndex];
+  }
+  return null;
+};
+
+
+/**
+ * Gets the change address for this transaction.
+ * @returns {Address|null} The change address if set, otherwise null.
+ */
+Transaction.prototype.getChangeAddress = function () {
+  return this._changeAddress ? this._changeAddress : null;
+};
+
+
+
+/**
+ * Add an output to the transaction.
+ *
+ * Beware that this resets all the signatures for inputs (in further versions,
+ * SIGHASH_SINGLE or SIGHASH_NONE signatures will not be reset).
+ *
+ * @param {(string|Address|Array<Address>)} address
+ * @param {number} amount in satoshis
+ * @return {Transaction} this, for chaining
+ */
+Transaction.prototype.to = function (address, amount) {
+  if (_.isArray(address)) {
+    var self = this;
+    _.each(address, function (to) {
+      self.to(to.address, to.satoshis);
+    });
+    return this;
+  }
+
+  $.checkArgument(JSUtil.isNaturalNumber(amount), 'Amount is expected to be a positive integer');
+  this.addOutput(
+    new Output({
+      script: Script(new Address(address)),
+      satoshis: amount,
+    }),
+  );
+  return this;
+};
+
+/**
+ * Add an OP_RETURN output to the transaction.
+ *
+ * Beware that this resets all the signatures for inputs (in further versions,
+ * SIGHASH_SINGLE or SIGHASH_NONE signatures will not be reset).
+ *
+ * @param {Buffer|string} value the data to be stored in the OP_RETURN output.
+ *    In case of a string, the UTF-8 representation will be stored
+ * @return {Transaction} this, for chaining
+ */
+Transaction.prototype.addData = function (value) {
+  this.addOutput(
+    new Output({
+      script: Script.buildDataOut(value),
+      satoshis: 0,
+    }),
+  );
+  return this;
+};
+
+/**
+ * Add an OP_FALSE | OP_RETURN output to the transaction.
+ *
+ * Beware that this resets all the signatures for inputs (in further versions,
+ * SIGHASH_SINGLE or SIGHASH_NONE signatures will not be reset).
+ *
+ * @param {Buffer|string} value the data to be stored in the OP_RETURN output.
+ *    In case of a string, the UTF-8 representation will be stored
+ * @return {Transaction} this, for chaining
+ */
+Transaction.prototype.addSafeData = function (value) {
+  this.addOutput(
+    new Output({
+      script: Script.buildSafeDataOut(value),
+      satoshis: 0,
+    }),
+  );
+  return this;
+};
+
+/**
+ * Add an output to the transaction.
+ *
+ * @param {Output} output the output to add.
+ * @return {Transaction} this, for chaining
+ */
+Transaction.prototype.addOutput = function (output) {
+  $.checkArgumentType(output, Output, 'output');
+  this._addOutput(output);
+  this._updateChangeOutput();
+  return this;
+};
+
+/**
+ * Remove all outputs from the transaction.
+ *
+ * @return {Transaction} this, for chaining
+ */
+Transaction.prototype.clearOutputs = function () {
+  this.outputs = [];
+  this._clearSignatures();
+  this._outputAmount = undefined;
+  this._changeIndex = undefined;
+  this._updateChangeOutput();
+  return this;
+};
+
+/**
+ * Adds an output to the transaction.
+ * @param {Output} output - The output to add to the transaction.
+ * @private
+ */
+Transaction.prototype._addOutput = function (output) {
+  this.outputs.push(output);
+  this._outputAmount = undefined;
+};
+
+/**
+ * Calculates or gets the total output amount in satoshis
+ *
+ * @return {Number} the transaction total output amount
+ * @private
+ */
+Transaction.prototype._getOutputAmount = function () {
+  if (_.isUndefined(this._outputAmount)) {
+    var self = this;
+    this._outputAmount = 0;
+    _.each(this.outputs, function (output) {
+      self._outputAmount += output.satoshis;
+    });
+  }
+  return this._outputAmount;
+};
+
+/**
+ * Calculates or gets the total input amount in satoshis
+ *
+ * @return {Number} the transaction total input amount
+ * @private
+ */
+Transaction.prototype._getInputAmount = function () {
+  if (_.isUndefined(this._inputAmount)) {
+    var self = this;
+    this._inputAmount = 0;
+    _.each(this.inputs, function (input) {
+      if (_.isUndefined(input.output)) {
+        throw new errors.Transaction.Input.MissingPreviousOutput();
+      }
+      self._inputAmount += input.output.satoshis;
+    });
+  }
+  return this._inputAmount;
+};
+
+/**
+ * Updates the change output of the transaction.
+ * - Removes existing change output if present.
+ * - Calculates available change amount after fee.
+ * - Adds new change output if amount is above dust threshold.
+ * - Clears any existing signatures.
+ * @throws {TransactionAlreadySealed} If transaction is already sealed.
+ * @private
+ */
+Transaction.prototype._updateChangeOutput = function () {
+  if (this.sealed) {
+    throw new errors.Transaction.TransactionAlreadySealed();
+  }
+
+  if (!this._changeScript) {
+    return;
+  }
+  if (!_.isUndefined(this._changeIndex)) {
+    this._removeOutput(this._changeIndex);
+  }
+  this._changeIndex = this.outputs.length;
+  this._addOutput(
+    new Output({
+      script: this._changeScript,
+      satoshis: 0,
+      data: this._changeData || ''
+    }),
+  );
+  var available = this.getUnspentValue();
+  var fee = this.getFee();
+  var changeAmount = available - fee;
+  this._removeOutput(this._changeIndex);
+  this._changeIndex = undefined;
+  if (changeAmount >= Transaction.DUST_AMOUNT) {
+    this._changeIndex = this.outputs.length;
+    this._addOutput(
+      new Output({
+        script: this._changeScript,
+        satoshis: changeAmount,
+        data: this._changeData || ''
+      }),
+    );
+  }
+  this._clearSignatures();
+};
+/**
+ * Calculates the fee of the transaction.
+ *
+ * If there's a fixed fee set, return that.
+ *
+ * If there is no change output set, the fee is the
+ * total value of the outputs minus inputs. Note that
+ * a serialized transaction only specifies the value
+ * of its outputs. (The value of inputs are recorded
+ * in the previous transaction outputs being spent.)
+ * This method therefore raises a "MissingPreviousOutput"
+ * error when called on a serialized transaction.
+ *
+ * If there's no fee set and no change address,
+ * estimate the fee based on size.
+ *
+ * @return {Number} fee of this transaction in satoshis
+ */
+Transaction.prototype.getFee = function () {
+  if (this.isCoinbase()) {
+    return 0;
+  }
+  if (!_.isUndefined(this._fee)) {
+    return this._fee;
+  }
+  // if no change output is set, fees should equal all the unspent amount
+  if (!this._changeScript) {
+    return this.getUnspentValue();
+  }
+  return this._estimateFee();
+};
+
+/**
+ * Estimates fee from serialized transaction size in bytes.
+ * @private
+ */
+Transaction.prototype._estimateFee = function () {
+  var estimatedSize = this._estimateSize();
+  return Math.ceil((estimatedSize / 1000) * (this._feePerKb || Transaction.FEE_PER_KB));
+};
+
+/**
+ * Calculates the unspent value (difference between input and output amounts) of the transaction.
+ * @returns {number} The unspent value (input amount minus output amount).
+ */
+Transaction.prototype.getUnspentValue = function () {
+  return this._getInputAmount() - this._getOutputAmount();
+};
+
+/**
+ * Clears all signatures from the transaction inputs.
+ * @private
+ */
+Transaction.prototype._clearSignatures = function () {
+  _.each(this.inputs, function (input) {
+    input.clearSignatures();
+  });
+};
+
+// 4    version
+// ???  num inputs (VARINT)
+// --- input list ---
+//
+// ???  num outputs (VARINT)
+// --- output list ---
+//      8       value
+//      ???     script size (VARINT)
+//      ???     script
+//
+// 4    locktime
+/**
+ * Gets the estimated size of the transaction.
+ * @returns {number} The estimated size in bytes.
+ */
+Transaction.prototype.getEstimateSize = function () {
+  return this._estimateSize();
+};
+
+/**
+ * Estimates the total size of the transaction in bytes.
+ * Calculates the sum of:
+ * - Fixed header size (version + locktime)
+ * - Varint-encoded input/output counts
+ * - Each input's estimated size
+ * - Each output's fixed size
+ * @returns {number} The estimated transaction size in bytes
+ * @private
+ */
+Transaction.prototype._estimateSize = function () {
+  var result = 4 + 4; // size of version + size of locktime
+  result += Varint(this.inputs.length).toBuffer().length;
+  result += Varint(this.outputs.length).toBuffer().length;
+  _.each(this.inputs, function (input) {
+    result += input._estimateSize();
+  });
+  _.each(this.outputs, function (output) {
+    result += output.getSize();
+  });
+  return result;
+};
+
+/**
+ * Removes an output from the transaction by index.
+ * @param {number} index - The index of the output to remove.
+ * @private
+ */
+Transaction.prototype._removeOutput = function (index) {
+  var output = this.outputs[index];
+  this.outputs = _.without(this.outputs, output);
+  this._outputAmount = undefined;
+};
+
+/**
+ * Removes an output from the transaction at the specified index and updates the change output.
+ * @param {number} index - The index of the output to remove.
+ */
+Transaction.prototype.removeOutput = function (index) {
+  this._removeOutput(index);
+  this._updateChangeOutput();
+};
+
+/**
+ * Sort a transaction's inputs and outputs according to BIP69
+ *
+ * @see {https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki}
+ * @return {Transaction} this
+ */
+Transaction.prototype.sort = function () {
+  this.sortInputs(function (inputs) {
+    var copy = Array.prototype.concat.apply([], inputs);
+    copy.sort(function (first, second) {
+      return first.prevTxId.compare(second.prevTxId) || first.outputIndex - second.outputIndex;
+    });
+    return copy;
+  });
+  this.sortOutputs(function (outputs) {
+    var copy = Array.prototype.concat.apply([], outputs);
+    copy.sort(function (first, second) {
+      return (
+        first.satoshis - second.satoshis ||
+        first.script.toBuffer().compare(second.script.toBuffer())
+      );
+    });
+    return copy;
+  });
+  return this;
+};
+
+/**
+ * Randomize this transaction's outputs ordering. The shuffling algorithm is a
+ * version of the Fisher-Yates shuffle.
+ *
+ * @return {Transaction} this
+ */
+Transaction.prototype.shuffleOutputs = function () {
+  return this.sortOutputs(_.shuffle);
+};
+
+/**
+ * Sort this transaction's outputs, according to a given sorting function that
+ * takes an array as argument and returns a new array, with the same elements
+ * but with a different order. The argument function MUST NOT modify the order
+ * of the original array
+ *
+ * @param {Function} sortingFunction
+ * @return {Transaction} this
+ */
+Transaction.prototype.sortOutputs = function (sortingFunction) {
+  var outs = sortingFunction(this.outputs);
+  return this._newOutputOrder(outs);
+};
+
+/**
+ * Sort this transaction's inputs, according to a given sorting function that
+ * takes an array as argument and returns a new array, with the same elements
+ * but with a different order.
+ *
+ * @param {Function} sortingFunction
+ * @return {Transaction} this
+ */
+Transaction.prototype.sortInputs = function (sortingFunction) {
+  this.inputs = sortingFunction(this.inputs);
+  this._clearSignatures();
+  return this;
+};
+
+/**
+ * Updates the order of transaction outputs while maintaining consistency.
+ * Validates that new outputs match original outputs before applying the change.
+ * Adjusts the change output index if it exists.
+ * 
+ * @param {Array} newOutputs - The new ordered outputs array
+ * @returns {Transaction} Returns the transaction instance for chaining
+ * @throws {Transaction.InvalidSorting} If output arrays don't match
+ * @private
+ */
+Transaction.prototype._newOutputOrder = function (newOutputs) {
+  var isInvalidSorting =
+    this.outputs.length !== newOutputs.length ||
+    _.difference(this.outputs, newOutputs).length !== 0;
+  if (isInvalidSorting) {
+    throw new errors.Transaction.InvalidSorting();
+  }
+
+  if (!_.isUndefined(this._changeIndex)) {
+    var changeOutput = this.outputs[this._changeIndex];
+    this._changeIndex = newOutputs.indexOf(changeOutput);
+  }
+
+  this.outputs = newOutputs;
+  return this;
+};
+
+/**
+ * Removes an input from the transaction by either its index or txId/outputIndex pair.
+ * @param {string|number} txId - Transaction ID (as hex string) or input index if outputIndex is omitted.
+ * @param {number} [outputIndex] - Output index of the input to remove (required if txId is string).
+ * @throws {Transaction.InvalidIndex} If input index is out of bounds.
+ */
+Transaction.prototype.removeInput = function (txId, outputIndex) {
+  var index;
+  if (!outputIndex && _.isNumber(txId)) {
+    index = txId;
+  } else {
+    index = _.findIndex(this.inputs, function (input) {
+      return input.prevTxId.toString('hex') === txId && input.outputIndex === outputIndex;
+    });
+  }
+  if (index < 0 || index >= this.inputs.length) {
+    throw new errors.Transaction.InvalidIndex(index, this.inputs.length);
+  }
+  var input = this.inputs[index];
+  this.inputs = _.without(this.inputs, input);
+  this._inputAmount = undefined;
+  this._updateChangeOutput();
+};
+
+
+/**
+ * Sign the transaction using one or more private keys.
+ *
+ * It tries to sign each input, verifying that the signature will be valid
+ * (matches a public key).
+ * @param {Buffer|Array<Buffer>} privateKey - Private key(s) to sign the transaction with.
+ * @param {number} [sigtype] - Optional signature type.
+ * @returns {Transaction} Returns the transaction instance for chaining.
+ * @throws {Error} Throws if not all UTXO information is available.
+ */
+Transaction.prototype.sign = function (privateKey, sigtype) {
+  $.checkState(
+    this.hasAllUtxoInfo(),
+    'Not all utxo information is available to sign the transaction.',
+  );
+  var self = this;
+  if (_.isArray(privateKey)) {
+    _.each(privateKey, function (privateKey) {
+      self.sign(privateKey, sigtype);
+    });
+    return this;
+  }
+  _.each(this.getSignatures(privateKey, sigtype), function (signature) {
+    self.applySignature(signature);
+  });
+
+  this._privateKey = privateKey;
+  this._sigType = sigtype;
+  return this;
+};
+
+/**
+ * Generates signatures for all inputs in the transaction using the provided private key.
+ * @param {string|PrivateKey} privKey - The private key to sign with (can be string or PrivateKey instance).
+ * @param {number} [sigtype=Signature.SIGHASH_ALL] - The signature hash type (defaults to SIGHASH_ALL).
+ * @returns {Array} Array of generated signatures for the transaction inputs.
+ */
+Transaction.prototype.getSignatures = function (privKey, sigtype) {
+  privKey = new PrivateKey(privKey);
+  // By default, signs using SIGHASH_ALL
+  sigtype = sigtype || Signature.SIGHASH_ALL;
+  var transaction = this;
+  var results = [];
+  var hashData = Hash.sha256ripemd160(privKey.publicKey.toBuffer());
+  _.each(this.inputs, function forEachInput(input, index) {
+    _.each(
+      input.getSignatures(transaction, privKey, index, sigtype, hashData),
+      function (signature) {
+        results.push(signature);
+      },
+    );
+  });
+  return results;
+};
+
+/**
+ * Add a signature to the transaction
+ *
+ * @param {Object} signature
+ * @param {number} signature.inputIndex
+ * @param {number} signature.sigtype
+ * @param {PublicKey} signature.publicKey
+ * @param {Signature} signature.signature
+ * @return {Transaction} this, for chaining
+ */
+Transaction.prototype.applySignature = function (signature) {
+  this.inputs[signature.inputIndex].addSignature(this, signature);
+  return this;
+};
+
+/**
+ * Checks if all inputs in the transaction are fully signed.
+ * @returns {boolean} True if all inputs have valid signatures, false otherwise.
+ * @throws {errors.Transaction.UnableToVerifySignature} If any input has an unrecognized script kind 
+ *         or insufficient information to verify signatures (common when deserializing transactions).
+ */
+Transaction.prototype.isFullySigned = function () {
+  _.each(this.inputs, function (input) {
+    if (input.isFullySigned === Input.prototype.isFullySigned) {
+      throw new errors.Transaction.UnableToVerifySignature(
+        'Unrecognized script kind, or not enough information to execute script.' +
+          'This usually happens when creating a transaction from a serialized transaction',
+      );
+    }
+  });
+  return _.every(
+    _.map(this.inputs, function (input) {
+      return input.isFullySigned();
+    }),
+  );
+};
+
+/**
+ * Validates a signature for a transaction input.
+ * @param {Object} signature - The signature object to validate.
+ * @throws {errors.Transaction.UnableToVerifySignature} If the input script is unrecognized or lacks execution info.
+ * @returns {boolean} True if the signature is valid for the specified input.
+ */
+Transaction.prototype.isValidSignature = function (signature) {
+  var self = this;
+  if (this.inputs[signature.inputIndex].isValidSignature === Input.prototype.isValidSignature) {
+    throw new errors.Transaction.UnableToVerifySignature(
+      'Unrecognized script kind, or not enough information to execute script.' +
+        'This usually happens when creating a transaction from a serialized transaction',
+    );
+  }
+  return this.inputs[signature.inputIndex].isValidSignature(self, signature);
+};
+
+
+/**
+ * Verifies a signature for this transaction.
+ * @param {Buffer} sig - The signature to verify.
+ * @param {Buffer} pubkey - The public key corresponding to the signature.
+ * @param {number} nin - The input index being signed.
+ * @returns {boolean} True if the signature is valid, false otherwise.
+ */
+Transaction.prototype.verifySignature = function (sig, pubkey, nin) {
+  return Sighash.verify(this, sig, pubkey, nin);
+};
+
+
+/**
+ * Check that a transaction passes basic sanity tests. If not, return a string
+ * describing the error. This function contains the same logic as
+ * CheckTransaction in bitcoin core.
+ * 
+ * Checks include:
+ * - Non-empty inputs and outputs
+ * - Valid output satoshis (non-negative, not exceeding MAX_MONEY)
+ * - No duplicate inputs
+ * - Coinbase script size validation (if coinbase)
+ * - Input null checks and verification (if not coinbase and notVerifyInput is false)
+ * 
+ * @param {boolean} [notVerifyInput=false] - Whether to skip input verification
+ * @returns {true|string} Returns true if valid, or an error message string if invalid
+ */
+Transaction.prototype.verify = function (notVerifyInput) {
+// Basic checks that don't depend on any context
+  if (this.inputs.length === 0) {
+    return 'transaction txins empty';
+  }
+
+  if (this.outputs.length === 0) {
+    return 'transaction txouts empty';
+  }
+
+  // Check for negative or overflow output values
+  var valueoutbn = new BN(0);
+  for (var i = 0; i < this.outputs.length; i++) {
+    var txout = this.outputs[i];
+
+    if (txout.invalidSatoshis()) {
+      return 'transaction txout ' + i + ' satoshis is invalid';
+    }
+    if (txout._satoshisBN.gt(new BN(Transaction.MAX_MONEY, 10))) {
+      return 'transaction txout ' + i + ' greater than MAX_MONEY';
+    }
+    valueoutbn = valueoutbn.add(txout._satoshisBN);
+    if (valueoutbn.gt(new BN(Transaction.MAX_MONEY))) {
+      return 'transaction txout ' + i + ' total output greater than MAX_MONEY';
+    }
+  }
+
+  // Check for duplicate inputs
+  var txinmap = {};
+  for (i = 0; i < this.inputs.length; i++) {
+    var txin = this.inputs[i];
+
+    var inputid = txin.prevTxId + ':' + txin.outputIndex;
+    if (!_.isUndefined(txinmap[inputid])) {
+      return 'transaction input ' + i + ' duplicate input';
+    }
+    txinmap[inputid] = true;
+  }
+
+  var isCoinbase = this.isCoinbase();
+  if (isCoinbase) {
+    var buf = this.inputs[0]._scriptBuffer;
+    if (buf.length < 2 || buf.length > 100) {
+      return 'coinbase transaction script size invalid';
+    }
+  } else {
+    for (i = 0; i < this.inputs.length; i++) {
+      if (this.inputs[i].isNull()) {
+        return 'transaction input ' + i + ' has null input';
+      }
+
+      if (!notVerifyInput) {
+        var res = this.inputs[i].verify(this, i);
+        if (!res.success) {
+          return 'transaction input ' + i + ' VerifyError: ' + res.error;
+        }
+      }
+    }
+  }
+  return true;
+};
+
+
+/**
+ * Checks if the transaction is a coinbase transaction.
+ * A coinbase transaction has exactly one input and that input is null.
+ * @returns {boolean} True if the transaction is a coinbase, false otherwise.
+ */
+Transaction.prototype.isCoinbase = function () {
+  return this.inputs.length === 1 && this.inputs[0].isNull();
+};
+
+
+/**
+ * Sets the input script for a transaction input.
+ * @param {number|Object} options - Either an input index number or an options object
+ * @param {number} [options.inputIndex=0] - Input index if options is an object
+ * @param {string} [options.privateKey] - Private key for signing
+ * @param {number} [options.sigtype=Signature.SIGHASH_ALL] - Signature hash type
+ * @param {boolean} [options.isLowS=false] - Whether to use low-S signatures
+ * @param {Function|Script} unlockScriptOrCallback - Either a script or callback function that returns a script
+ * @returns {Transaction} Returns the transaction instance for chaining
+ */
+Transaction.prototype.setInputScript = function (options, unlockScriptOrCallback) {
+  var inputIndex = 0;
+  var privateKey;
+  var sigtype;
+  var isLowS = false;
+  if (typeof options === 'number') {
+    inputIndex = options;
+    sigtype = Signature.SIGHASH_ALL;
+  } else {
+    inputIndex = options.inputIndex || 0;
+    privateKey = options.privateKey;
+    sigtype = options.sigtype || Signature.SIGHASH_ALL;
+    isLowS = options.isLowS || false;
+  }
+
+  if (unlockScriptOrCallback instanceof Function) {
+    var outputInPrevTx = this.inputs[inputIndex].output;
+    this._inputsMap.set(inputIndex, {
+      sigtype,
+      privateKey,
+      isLowS,
+      callback: unlockScriptOrCallback,
+    });
+    var unlockScript = unlockScriptOrCallback(this, outputInPrevTx);
+    this.inputs[inputIndex].setScript(unlockScript);
+  } else {
+    this.inputs[inputIndex].setScript(unlockScriptOrCallback);
+  }
+
+  return this;
+};
+
+
+/**
+ * Sets the sequence number for a specific transaction input.
+ * @param {number} inputIndex - The index of the input to update.
+ * @param {number} sequence - The sequence number to set.
+ * @returns {Transaction} Returns the transaction instance for chaining.
+ */
+Transaction.prototype.setInputSequence = function (inputIndex, sequence) {
+  this.inputs[inputIndex].sequenceNumber = sequence;
+  return this;
+};
+
+
+/**
+ * Sets an output at the specified index, either directly or via a callback function.
+ * If a callback is provided, it will be invoked with the transaction instance to generate the output value.
+ * Automatically updates the change output after setting.
+ * @param {number} outputIndex - The index of the output to set
+ * @param {any|Function} outputOrcb - The output value or a callback function that returns the output value
+ * @returns {Transaction} Returns the transaction instance for chaining
+ */
+Transaction.prototype.setOutput = function (outputIndex, outputOrcb) {
+  if (outputOrcb instanceof Function) {
+    this._outputsMap.set(outputIndex, outputOrcb);
+    this.outputs[outputIndex] = outputOrcb(this);
+  } else {
+    this.outputs[outputIndex] = outputOrcb;
+  }
+
+  this._updateChangeOutput();
+  return this;
+};
+
+
+/**
+ * Seals the transaction by processing all outputs and inputs.
+ * - For each output, executes the registered callback to generate the final output.
+ * - Updates the change output if applicable.
+ * - For each input, generates and sets the unlock script using the registered callback.
+ * - If a private key is provided, signs the transaction.
+ * - Marks the transaction as sealed and returns the instance.
+ * @returns {Transaction} The sealed transaction instance.
+ */
+Transaction.prototype.seal = function () {
+  var self = this;
+
+  this._outputsMap.forEach(function (callback, key) {
+    self.outputs[key] = callback(self);
+  });
+
+  this._updateChangeOutput();
+
+  this._inputsMap.forEach(function (options, key) {
+    var outputInPrevTx = self.inputs[key].output;
+    var unlockScript = options.callback(self, outputInPrevTx);
+    self.inputs[key].setScript(unlockScript);
+  });
+
+  if (this._privateKey) {
+    this.sign(this._privateKey, this._sigType);
+  }
+
+  this.sealed = true;
+
+  return this;
+};
+
+
+/**
+ * Sets the lock time for the transaction.
+ * @param {number} nLockTime - The lock time to set.
+ * @returns {Transaction} Returns the transaction instance for chaining.
+ */
+Transaction.prototype.setLockTime = function (nLockTime) {
+  this.nLockTime = nLockTime;
+  return this;
+};
+
+
+/**
+ * Gets the amount of change (in satoshis) for this transaction.
+ * @returns {number} The change amount in satoshis, or 0 if no change exists.
+ */
+Transaction.prototype.getChangeAmount = function () {
+  if (_.isUndefined(this._changeIndex)) {
+    return 0;
+  }
+
+  return this.outputs[this._changeIndex].satoshis;
+};
+
+
+/**
+ * Gets the estimated fee for the transaction.
+ * @returns {number} The estimated fee value.
+ */
+Transaction.prototype.getEstimateFee = function () {
+  return this._estimateFee();
+};
+
+
+/**
+ * Checks if the transaction's fee rate meets or exceeds the expected rate.
+ * @param {number} [feePerKb] - Optional fee per KB (in satoshis). Falls back to instance or default fee.
+ * @returns {boolean} True if actual fee rate (fee/size) >= expected rate.
+ */
+Transaction.prototype.checkFeeRate = function (feePerKb) {
+  var fee = this.getUnspentValue();
+
+  var estimatedSize = this._estimateSize();
+  var expectedRate = (feePerKb || this._feePerKb || Transaction.FEE_PER_KB) / 1000;
+  var realFeeRate = fee / estimatedSize;
+  return realFeeRate >= expectedRate;
+};
+
+
+/**
+ * Serializes the transaction's inputs (prevTxId and outputIndex) into a hex string.
+ * @returns {string} Hex-encoded serialized input data.
+ */
+Transaction.prototype.prevouts = function () {
+  var writer = new BufferWriter();
+
+  _.each(this.inputs, function (input) {
+    writer.writeReverse(input.prevTxId);
+    writer.writeUInt32LE(input.outputIndex);
+  });
+
+  var buf = writer.toBuffer();
+  return buf.toString('hex');
+};
+
+
+/**
+ * Checks if the transaction is sealed.
+ * @returns {boolean} True if the transaction is sealed, false otherwise.
+ */
+Transaction.prototype.isSealed = function () {
+  return this.sealed;
+};
+
+/**
+ * Gets the preimage for a transaction input.
+ * @param {number} inputIndex - The index of the input to get the preimage for.
+ * @param {number} [sigtype=Signature.SIGHASH_ALL] - The signature hash type.
+ * @param {boolean} [isLowS=false] - Whether to use low-S signatures.
+ * @returns {*} The preimage for the specified input.
+ */
+Transaction.prototype.getPreimage = function (inputIndex, sigtype, isLowS) {
+  $.checkArgumentType(inputIndex, 'number', 'inputIndex');
+  sigtype = sigtype || Signature.SIGHASH_ALL;
+  isLowS = isLowS || false;
+  inputIndex = inputIndex || 0;
+  return this.inputs[inputIndex].getPreimage(this, inputIndex, sigtype, isLowS);
+};
+
+/**
+ * Gets the signature(s) for a transaction input.
+ * @param {number} inputIndex - Index of the input to sign.
+ * @param {Array|Buffer|string} [privateKeys] - Private key(s) to sign with. Defaults to input's privateKey or transaction's _privateKey.
+ * @param {number} [sigtypes] - Signature hash type. Defaults to SIGHASH_ALL.
+ * @returns {string|Array} - Single signature hex string or array of signatures. Returns empty array if no privateKeys provided.
+ */
+Transaction.prototype.getSignature = function (inputIndex, privateKeys, sigtypes) {
+  $.checkArgumentType(inputIndex, 'number', 'inputIndex');
+  var results = [];
+  var inputOpt = (this._inputsMap || new Map()).get(inputIndex);
+
+  privateKeys = privateKeys || (inputOpt ? inputOpt.privateKey : this._privateKey);
+
+  if (privateKeys) {
+    sigtypes = sigtypes || Signature.SIGHASH_ALL;
+    var sigs = this.inputs[inputIndex].getSignatures(this, privateKeys, inputIndex, sigtypes);
+
+    _.each(sigs, function (sig) {
+      results.push(sig.signature.toTxFormat().toString('hex'));
+    });
+
+    if (results.length === 1) {
+      return results[0];
+    }
+
+    return results;
+  }
+
+  return [];
+};
+
+/**
+ * Adds an input to the transaction from a previous transaction's output.
+ * @param {Transaction} prevTx - The previous transaction containing the output to spend.
+ * @param {number} [outputIndex=0] - The index of the output in the previous transaction.
+ * @returns {Transaction} The transaction instance for chaining.
+ * @throws {Error} If prevTx is not a valid Transaction.
+ */
+Transaction.prototype.addInputFromPrevTx = function (prevTx, outputIndex) {
+  $.checkArgumentType(prevTx, Transaction, 'prevTx');
+
+  var outputIdx = outputIndex || 0;
+
+  const output = prevTx.outputs[outputIdx];
+
+  if (output.script.isPublicKeyHashOut()) {
+    return this.addInput(
+      new PublicKeyHashInput({
+        prevTxId: prevTx.id,
+        outputIndex: outputIdx,
+        script: new Script(''), // placeholder
+        output: output,
+      }),
+    );
+  } else {
+    return this.addInput(
+      new Input({
+        prevTxId: prevTx.id,
+        outputIndex: outputIdx,
+        script: new Script(''), // placeholder
+        output: output,
+      }),
+    );
+  }
+};
+
+/**
+ * Adds a dummy input to the transaction with the specified script and satoshis.
+ * The dummy input uses a placeholder script and a fixed previous transaction ID.
+ * 
+ * @param {Script} script - The script to use for the output of the dummy input.
+ * @param {number} satoshis - The amount in satoshis for the output of the dummy input.
+ * @returns {Transaction} The transaction instance for chaining.
+ */
+Transaction.prototype.addDummyInput = function (script, satoshis) {
+  $.checkArgumentType(script, Script, 'script');
+  $.checkArgumentType(satoshis, 'number', 'satoshis');
+
+  return this.addInput(
+    new Input({
+      prevTxId: 'a477af6b2667c29670467e4e0728b685ee07b240235771862318e29ddbe58458',
+      outputIndex: 0,
+      script: new Script(''), // placeholder
+      output: new Output({
+        script: script,
+        satoshis: satoshis,
+      }),
+    }),
+  );
+};
+
+/**
+ * Same as change(addresss), but using the address of Transaction.DUMMY_PRIVATEKEY as default change address
+ *
+ * Beware that this resets all the signatures for inputs (in further versions,
+ * SIGHASH_SINGLE or SIGHASH_NONE signatures will not be reset).
+ *
+ * @return {Transaction} this, for chaining
+ */
+Transaction.prototype.dummyChange = function () {
+  return this.change(Transaction.DUMMY_PRIVATEKEY.toAddress());
+};
+
+/**
+ * Verifies the script for a specific transaction input.
+ * @param {number} inputIndex - Index of the input to verify.
+ * @throws {errors.Transaction.Input.MissingInput} If input at given index doesn't exist.
+ * @returns {boolean} True if the script verification passes.
+ */
+Transaction.prototype.verifyScript = function (inputIndex) {
+  $.checkArgumentType(inputIndex, 'number', 'inputIndex');
+
+  if (!this.inputs[inputIndex]) {
+    throw new errors.Transaction.Input.MissingInput();
+  }
+
+  return this.inputs[inputIndex].verify(this, inputIndex);
+};
+
+
+/**
+ * Verifies the input script for a specific input index in the transaction.
+ * @param {number} inputIndex - The index of the input to verify.
+ * @returns {boolean} True if the input script is valid, false otherwise.
+ */
+Transaction.prototype.verifyInputScript = function (inputIndex) {
+  return this.verifyScript(inputIndex);
+};
+
+/**
+ * Gets the amount of satoshis for a specific transaction input.
+ * @param {number} inputIndex - The index of the input to query.
+ * @returns {number} The satoshis amount of the specified input.
+ * @throws {errors.Transaction.Input.MissingInput} If the input at the specified index doesn't exist.
+ */
+Transaction.prototype.getInputAmount = function (inputIndex) {
+  $.checkArgumentType(inputIndex, 'number', 'inputIndex');
+
+  if (!this.inputs[inputIndex]) {
+    throw new errors.Transaction.Input.MissingInput();
+  }
+
+  return this.inputs[inputIndex].output.satoshis;
+};
+
+/**
+ * Gets the output amount in satoshis for the specified output index.
+ * @param {number} outputIndex - The index of the output to retrieve.
+ * @returns {number} The output amount in satoshis.
+ * @throws {errors.Transaction.MissingOutput} If the output index is invalid.
+ */
+Transaction.prototype.getOutputAmount = function (outputIndex) {
+  $.checkArgumentType(outputIndex, 'number', 'outputIndex');
+
+  if (!this.outputs[outputIndex]) {
+    throw new errors.Transaction.MissingOutput();
+  }
+
+  return this.outputs[outputIndex].satoshis;
+};
+
+
+/**
+ * Assigns the Input class to the Transaction namespace.
+ * @memberof Transaction
+ * @name Input
+ * @alias Input
+ */
+Transaction.Input = Input;
+/**
+ * Assigns the Output class to Transaction.Output property.
+ * @memberof Transaction
+ * @name Output
+ * @alias Output
+ */
+Transaction.Output = Output;
+
+/**
+ * Attaches the Sighash module to the Transaction class.
+ * @memberof Transaction
+ * @name Sighash
+ * @alias Sighash
+ */
+Transaction.Sighash = Sighash;
+/**
+ * Attaches the UnspentOutput class to the Transaction namespace.
+ * @memberof Transaction
+ * @name UnspentOutput
+ * @alias UnspentOutput
+ */
+Transaction.UnspentOutput = UnspentOutput;
+
+/**
+ * Attaches the TransactionSignature class to the Transaction namespace.
+ * @memberof Transaction
+ * @name Signature
+ * @alias TransactionSignature
+ */
+Transaction.Signature = TransactionSignature;
+
+
+module.exports = Transaction;