@opcat-labs/opcat 1.0.1 → 1.0.2

package/esm/transaction/output.js

@@ -0,0 +1,316 @@
+'use strict';
+
+import _ from '../util/_.js';
+import BN from '../crypto/bn.js';
+import JSUtil from '../util/js.js';
+import BufferWriter from '../encoding/bufferwriter.js';
+import Varint from '../encoding/varint.js';
+import Script from '../script/index.js';
+import $ from '../util/preconditions.js';
+import errors from '../errors/index.js';
+import Hash from '../crypto/hash.js';
+
+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);
+  }
+  if (_.isObject(args)) {
+    this.satoshis = args.satoshis;
+    if (Buffer.isBuffer(args.script)) {
+      this.setScriptFromBuffer(args.script);
+    } else {
+      var script;
+      if (_.isString(args.script) && JSUtil.isHexa(args.script)) {
+        script = Buffer.from(args.script, 'hex');
+      } else {
+        script = args.script;
+      }
+      this.setScript(script);
+    }
+    this.setData(args.data)
+  } else {
+    throw new TypeError('Unrecognized argument for Output');
+  }
+}
+/**
+ * Gets or sets the script associated with this Output instance.
+ * @memberof Output.prototype
+ * @name script
+ */
+Object.defineProperty(Output.prototype, 'script', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    return this._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,
+  get: function () {
+    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,
+  get: function () {
+    return this._satoshis;
+  },
+  set: function (num) {
+    if (num instanceof BN) {
+      this._satoshisBN = num;
+      this._satoshis = num.toNumber();
+    } else if (_.isString(num)) {
+      this._satoshis = parseInt(num);
+      this._satoshisBN = BN.fromNumber(this._satoshis);
+    } else {
+      $.checkArgument(JSUtil.isNaturalNumber(num), 'Output satoshis is not a natural number');
+      this._satoshisBN = BN.fromNumber(num);
+      this._satoshis = num;
+    }
+    $.checkState(JSUtil.isNaturalNumber(this._satoshis), 'Output satoshis is not a natural number');
+  },
+});
+
+/**
+ * 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';
+  }
+  if (this._satoshis !== this._satoshisBN.toNumber()) {
+    return 'transaction txout satoshis has corrupted value';
+  }
+  if (this._satoshis < 0) {
+    return 'transaction txout negative';
+  }
+  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,
+  get: function () {
+    return this._satoshisBN;
+  },
+  set: function (num) {
+    this._satoshisBN = num;
+    this._satoshis = num.toNumber();
+    $.checkState(JSUtil.isNaturalNumber(this._satoshis), 'Output satoshis is not a natural number');
+  },
+});
+
+/**
+ * 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,
+  };
+  obj.script = this._script.toBuffer().toString('hex');
+  obj.data = this._data.toString('hex')
+  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([])
+    return;
+  }
+  if (Buffer.isBuffer(data)) {
+    this._data = data
+  } else if (_.isString(data) && JSUtil.isHexa(data)) {
+    this._data = Buffer.from(data, 'hex')
+  } else {
+    throw new TypeError('Invalid argument type: data for output.setData')
+  }
+}
+
+/**
+ * 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);
+    this._script._isOutput = true;
+  } catch (e) {
+    if (e instanceof errors.Script.InvalidBuffer) {
+      this._script = null;
+    } else {
+      throw e;
+    }
+  }
+};
+
+/**
+ * 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;
+    this._script._isOutput = true;
+  } else if (_.isString(script)) {
+    this._script = Script.fromString(script);
+    this._script._isOutput = true;
+  } else if (Buffer.isBuffer(script)) {
+    this.setScriptFromBuffer(script);
+  } else {
+    throw new TypeError('Invalid argument type: script');
+  }
+  return this;
+};
+
+/**
+ * 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) {
+    scriptStr = this.script.inspect();
+  }
+  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()
+  var scriptSize = br.readVarintNum()
+  if (scriptSize !== 0) {
+    if (br.remaining() < scriptSize) {
+      throw new TypeError('Unrecognized Output')
+    }
+    obj.script = br.read(scriptSize)
+  } else {
+    obj.script = Buffer.from([])
+  }
+  var dataSize = br.readVarintNum()
+  if (dataSize !== 0) {
+    if (br.remaining() < dataSize) {
+      throw new TypeError('Unrecognized Output')
+    }
+    obj.data = br.read(dataSize)
+  } else {
+    obj.data = Buffer.from([])
+  }
+  return new Output(obj)
+}
+
+/**
+ * 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')
+  if (!writer) {
+    writer = new BufferWriter();
+  }
+  writer.writeUInt64LEBN(this._satoshisBN);
+  var script = this._script.toBuffer();
+  var data = this._data
+  if(hashScriptPubkey) {
+    writer.write(Hash.sha256(script))
+    writer.write(Hash.sha256(data))
+  } else {
+    writer.writeVarintNum(script.length);
+    writer.write(script);
+    writer.writeVarintNum(data.length)
+    writer.write(data)
+  }
+
+
+  return writer
+};
+
+/**
+ * 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 () {
+  var scriptSize = this.script.toBuffer().length;
+  var dataSize = this.data.length
+  var varintSize = Varint(scriptSize).toBuffer().length + Varint(dataSize).toBuffer().length
+  return 8 + varintSize + scriptSize + dataSize
+};
+
+/**
+ * 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());
+}
+
+export default Output;

package/{lib → esm}/transaction/sighash.js

@@ -1,15 +1,24 @@
 'use strict'
-var Signature = require('../crypto/signature')
-var Script = require('../script')
-var Output = require('./output')
-var BufferReader = require('../encoding/bufferreader')
-var BufferWriter = require('../encoding/bufferwriter')
-var Hash = require('../crypto/hash')
-var ECDSA = require('../crypto/ecdsa')
-var $ = require('../util/preconditions')
-var _ = require('../util/_')
+import Signature from '../crypto/signature.js';
+import Script from '../script/index.js';
+import Output from './output.js';
+import BufferReader from '../encoding/bufferreader.js';
+import BufferWriter from '../encoding/bufferwriter.js';
+import Hash from '../crypto/hash.js';
+import ECDSA from '../crypto/ecdsa.js';
+import $ from '../util/preconditions.js';
+import _ from '../util/_.js';
 
 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.
@@ -22,7 +31,7 @@ var SIGHASH_SINGLE_BUG = Buffer.from('000000000000000000000000000000000000000000
  * @param {satoshisBN} input's amount (for  ForkId signatures)
  *
  */
-var sighashPreimage = function sighashPreimage (transaction, sighashType, inputNumber) {
+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')
@@ -100,6 +109,22 @@ var sighashPreimage = function sighashPreimage (transaction, sighashType, inputN
   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.
@@ -110,8 +135,8 @@ var sighashPreimage = function sighashPreimage (transaction, sighashType, inputN
  * @param {number} inputNumber the input index for the signature
  *
  */
-var sighash = function sighash (transaction, sighashType, inputNumber) {
-  var preimage = sighashPreimage(transaction, sighashType, inputNumber)
+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()
@@ -127,8 +152,8 @@ var sighash = function sighash (transaction, sighashType, inputNumber) {
  * @param {number} inputIndex
  * @return {Signature}
  */
-function sign (transaction, privateKey, sighashType, inputIndex) {
-  var hashbuf = sighash(transaction, sighashType, inputIndex)
+Sighash.sign = function (transaction, privateKey, sighashType, inputIndex) {
+  var hashbuf = Sighash.sighash(transaction, sighashType, inputIndex)
 
   var sig = ECDSA.sign(hashbuf, privateKey, 'little').set({
     nhashtype: sighashType
@@ -149,19 +174,14 @@ function sign (transaction, privateKey, sighashType, inputIndex) {
  * @param {flags} verification flags
  * @return {boolean}
  */
-function verify (transaction, signature, publicKey, inputIndex) {
+Sighash.verify = function (transaction, signature, publicKey, inputIndex) {
   $.checkArgument(!_.isUndefined(transaction))
   $.checkArgument(!_.isUndefined(signature) && !_.isUndefined(signature.nhashtype))
-  var hashbuf = sighash(transaction, signature.nhashtype, inputIndex)
+  var hashbuf = Sighash.sighash(transaction, signature.nhashtype, inputIndex)
   return ECDSA.verify(hashbuf, signature, publicKey, 'little')
 }
 
 /**
  * @namespace Signing
  */
-module.exports = {
-  sighashPreimage: sighashPreimage,
-  sighash: sighash,
-  sign: sign,
-  verify: verify
-}
+export default Sighash;

package/esm/transaction/signature.js

@@ -0,0 +1,120 @@
+'use strict';
+
+import _ from '../util/_.js';
+import $ from '../util/preconditions.js';
+import inherits from 'inherits';
+import JSUtil from '../util/js.js';
+import PublicKey from '../publickey.js';
+import errors from '../errors/index.js';
+import Signature from '../crypto/signature.js';
+
+/**
+ * @desc
+ * Wrapper around Signature with fields related to signing a transaction specifically
+ *
+ * @param {Object|string|TransactionSignature} arg
+ * @constructor
+ */
+function TransactionSignature(arg) {
+  if (!(this instanceof TransactionSignature)) {
+    return new TransactionSignature(arg);
+  }
+  if (arg instanceof TransactionSignature) {
+    return arg;
+  }
+  if (_.isObject(arg)) {
+    return this._fromObject(arg);
+  }
+  throw new errors.InvalidArgument('TransactionSignatures must be instantiated from an object');
+}
+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);
+  this.prevTxId = Buffer.isBuffer(arg.prevTxId) ? arg.prevTxId : Buffer.from(arg.prevTxId, 'hex');
+  this.outputIndex = arg.outputIndex;
+  this.inputIndex = arg.inputIndex;
+  this.signature =
+    arg.signature instanceof Signature
+      ? arg.signature
+      : Buffer.isBuffer(arg.signature)
+      ? Signature.fromBuffer(arg.signature)
+      : Signature.fromString(arg.signature);
+  this.sigtype = arg.sigtype;
+  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');
+  $.checkArgument(!_.isUndefined(arg.outputIndex), 'outputIndex');
+  $.checkState(_.isNumber(arg.inputIndex), 'inputIndex must be a number');
+  $.checkState(_.isNumber(arg.outputIndex), 'outputIndex must be a number');
+  $.checkArgument(arg.signature, 'signature');
+  $.checkArgument(arg.prevTxId, 'prevTxId');
+  $.checkState(
+    arg.signature instanceof Signature ||
+      Buffer.isBuffer(arg.signature) ||
+      JSUtil.isHexa(arg.signature),
+    'signature must be a buffer or hexa value',
+  );
+  $.checkState(
+    Buffer.isBuffer(arg.prevTxId) || JSUtil.isHexa(arg.prevTxId),
+    'prevTxId must be a buffer or hexa value',
+  );
+  $.checkArgument(arg.sigtype, 'sigtype');
+  $.checkState(_.isNumber(arg.sigtype), 'sigtype must be a number');
+};
+
+/**
+ * Serializes a transaction to a plain JS object
+ * @return {Object}
+ */
+TransactionSignature.prototype.toObject = TransactionSignature.prototype.toJSON =
+  function toObject() {
+    return {
+      publicKey: this.publicKey.toString(),
+      prevTxId: this.prevTxId.toString('hex'),
+      outputIndex: this.outputIndex,
+      inputIndex: this.inputIndex,
+      signature: this.signature.toString(),
+      sigtype: this.sigtype,
+    };
+  };
+
+/**
+ * Builds a TransactionSignature from an object
+ * @param {Object} object
+ * @return {TransactionSignature}
+ */
+TransactionSignature.fromObject = function (object) {
+  $.checkArgument(object);
+  return new TransactionSignature(object);
+};
+
+export default TransactionSignature;