@opcat-labs/opcat 1.0.1 → 1.0.3

package/esm/script/write-i32-le.js

@@ -0,0 +1,17 @@
+function writeI32LE(writer, n) {
+  if (n < -2147483648 || n > 2147483647)
+    throw new Error('Out of range. It must be >= -2147483648 and <= 2147483647.');
+
+  const buffer = new Uint8Array(4);
+  buffer[0] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[1] = n % 256;
+  n = n >> 8;
+  buffer[2] = n % 256;
+  n = n >> 8;
+  buffer[3] = n;
+
+  return writer.write(buffer);
+}
+
+export default writeI32LE;

package/esm/script/write-push-data.js

@@ -0,0 +1,35 @@
+function writePushData(writer, buffer) {
+  // It is possible to optimize buffers that only store numbers 1-16, or -1, by using the OP_N opcodes.
+  // But we say "push data" is always stored using OP_0 or OP_PUSH(N) so that it's easy to identify and
+  // extract, and also because there is some ambiguity around OP_0 if we don't do this.
+  if (buffer.length === 0) {
+    writer.write([0]);
+  } else if (buffer.length <= 75) {
+    writer.write([buffer.length]); // OP_PUSH(buffer.length)
+    writer.write(buffer);
+  } else if (buffer.length <= 0xff) {
+    writer.write([76, buffer.length]); // OP_PUSHDATA1
+    writer.write(buffer);
+  } else if (buffer.length <= 0xffff) {
+    writer.write([77, buffer.length % 256, buffer.length >> 8]); // OP_PUSHDATA2
+    writer.write(buffer);
+  } else if (buffer.length <= 0xffffffff) {
+    const prefix = new Uint8Array(5);
+    prefix[0] = 78; // OP_PUSHDATA4
+    let n = buffer.length;
+    prefix[1] = n % 256;
+    n = Math.floor(n / 256);
+    prefix[2] = n % 256;
+    n = Math.floor(n / 256);
+    prefix[3] = n % 256;
+    n = Math.floor(n / 256);
+    prefix[4] = n;
+    writer.write(prefix);
+    writer.write(buffer);
+  } else {
+    throw new Error('data too large');
+  }
+  return writer;
+}
+
+export default writePushData;

package/esm/script/write-u16-le.js

@@ -0,0 +1,12 @@
+function writeU16LE(writer, n) {
+  if (n > 0xffff) throw new Error('number too large');
+
+  const buffer = new Uint8Array(2);
+  buffer[0] = n % 256;
+  n = n >> 8;
+  buffer[1] = n % 256;
+
+  return writer.write(buffer);
+}
+
+export default writeU16LE;

package/esm/script/write-u32-le.js

@@ -0,0 +1,16 @@
+function writeU32LE(writer, n) {
+  if (n > 0xffffffff) throw new Error('number too large');
+
+  const buffer = new Uint8Array(4);
+  buffer[0] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[1] = n % 256;
+  n = n >> 8;
+  buffer[2] = n % 256;
+  n = n >> 8;
+  buffer[3] = n;
+
+  return writer.write(buffer);
+}
+
+export default writeU32LE;

package/esm/script/write-u64-le.js

@@ -0,0 +1,24 @@
+function writeU64LE(writer, n) {
+  if (n > Number.MAX_SAFE_INTEGER) throw new Error('number too large');
+
+  const buffer = new Uint8Array(8);
+  buffer[0] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[1] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[2] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[3] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[4] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[5] = n % 256;
+  n = n >> 8;
+  buffer[6] = n % 256;
+  n = n >> 8;
+  buffer[7] = n;
+
+  return writer.write(buffer);
+}
+
+export default writeU64LE;

package/esm/script/write-u8-le.js

@@ -0,0 +1,8 @@
+function writeU8LE(writer, n) {
+  if (n > 0xff) throw new Error('number too large');
+  const buffer = new Uint8Array(1);
+  buffer[0] = n;
+  return writer.write(buffer);
+}
+
+export default writeU8LE;

package/esm/script/write-varint.js

@@ -0,0 +1,46 @@
+function writeVarint(writer, n) {
+  if (n > Number.MAX_SAFE_INTEGER) throw new Error('varint too large');
+
+  if (n <= 0xfc) {
+    return writer.write([n]);
+  }
+
+  if (n <= 0xffff) {
+    return writer.write([0xfd, n % 256, Math.floor(n / 256)]);
+  }
+
+  if (n <= 0xffffffff) {
+    const buffer = new Uint8Array(5);
+    buffer[0] = 0xfe;
+    buffer[1] = n % 256;
+    n = Math.floor(n / 256);
+    buffer[2] = n % 256;
+    n = Math.floor(n / 256);
+    buffer[3] = n % 256;
+    n = Math.floor(n / 256);
+    buffer[4] = n;
+    return writer.write(buffer);
+  }
+
+  // n <= 0xffffffffffffffff
+  const buffer = new Uint8Array(9);
+  buffer[0] = 0xff;
+  buffer[1] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[2] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[3] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[4] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[5] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[6] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[7] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[8] = n;
+  return writer.write(buffer);
+}
+
+export default writeVarint;

package/esm/transaction/index.js

@@ -0,0 +1,5 @@
+import Transaction from './transaction.js';
+
+export default Transaction;
+
+

package/esm/transaction/input/index.js

@@ -0,0 +1,33 @@
+
+import Input from './input.js';
+import PublicKeyInput from './publickey.js';
+import PublicKeyHashInput from './publickeyhash.js';
+import MultiSigInput from './multisig.js';
+
+
+/**
+ * Attaches the PublicKeyInput class to the Input namespace.
+ * @memberof Input
+ * @name PublicKey
+ * @alias PublicKeyInput
+ */
+Input.PublicKey = PublicKeyInput;
+
+
+/**
+ * Attaches the PublicKeyHashInput class to the Input namespace.
+ * @memberof Input
+ * @name PublicKeyHash
+ * @alias PublicKeyHashInput
+ */
+Input.PublicKeyHash = PublicKeyHashInput;
+/**
+ * Attaches the PublicKeyHashInput class to the Input namespace.
+ * @memberof Input
+ * @name MultiSig
+ * @alias MultiSigInput
+ */
+Input.MultiSig = MultiSigInput;
+
+
+export default Input;

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

@@ -1,40 +1,34 @@
 'use strict';
 
-var _ = require('../../util/_');
-var $ = require('../../util/preconditions');
-var errors = require('../../errors');
-var BufferWriter = require('../../encoding/bufferwriter');
-var JSUtil = require('../../util/js');
-var Script = require('../../script');
-var Sighash = require('../sighash');
-var Output = require('../output');
-var Signature = require('../../crypto/signature');
-var TransactionSignature = require('../signature');
-var Hash = require('../../crypto/hash');
-var Interpreter = require('../../script/interpreter');
-var Opcode = require('../../opcode');
-const PrivateKey = require('../../privatekey');
+import _ from '../../util/_.js';
+import $ from '../../util/preconditions.js';
+import errors from '../../errors/index.js';
+import BufferWriter from '../../encoding/bufferwriter.js';
+import JSUtil from '../../util/js.js';
+import Script from '../../script/index.js';
+import Sighash from '../sighash.js';
+import Output from '../output.js';
+import Signature from '../../crypto/signature.js';
+import TransactionSignature from '../signature.js';
+import Hash from '../../crypto/hash.js';
+import PrivateKey from '../../privatekey.js';
 
 var MAXINT = 0xffffffff; // Math.pow(2, 32) - 1;
 var DEFAULT_RBF_SEQNUMBER = MAXINT - 2;
 var DEFAULT_SEQNUMBER = MAXINT;
 var DEFAULT_LOCKTIME_SEQNUMBER = MAXINT - 1;
 
-function getLowSPreimage(tx, sigtype, inputIndex, subscript, inputAmount) {
-  var i = 0;
-  do {
-    var preimage = Sighash.sighashPreimage(tx, sigtype, inputIndex, subscript, inputAmount);
-
-    var sighash = Hash.sha256sha256(preimage);
-
-    if (_.isPositiveNumber(sighash.readUInt8()) && _.isPositiveNumber(sighash.readUInt8(31))) {
-      return preimage;
-    }
-
-    tx.nLockTime++;
-  } while (i < Number.MAX_SAFE_INTEGER);
-}
-
+/**
+ * Creates an Input instance from parameters.
+ * @constructor
+ * @param {Object} params - Input parameters object
+ * @param {string|Buffer} params.prevTxId - Previous transaction ID (hex string or Buffer)
+ * @param {number} params.outputIndex - Output index in previous transaction
+ * @param {Output} [params.output] - Output instance or output parameters
+ * @param {number} [params.sequenceNumber] - Sequence number (defaults to DEFAULT_SEQNUMBER)
+ * @param {Script|Buffer|string} [params.script] - Script instance, buffer or hex string
+ * @returns {Input} New Input instance or initialized instance if params provided.
+ */
 function Input(params) {
   if (!(this instanceof Input)) {
     return new Input(params);
@@ -51,6 +45,12 @@ Input.DEFAULT_RBF_SEQNUMBER = DEFAULT_RBF_SEQNUMBER;
 // txid + output index + sequence number
 Input.BASE_SIZE = 32 + 4 + 4;
 
+/**
+ * Gets or sets the script associated with this input.
+ * @memberof Input.prototype
+ * @name script
+ * @return {Script}
+ */
 Object.defineProperty(Input.prototype, 'script', {
   configurable: false,
   enumerable: true,
@@ -66,15 +66,40 @@ Object.defineProperty(Input.prototype, 'script', {
   },
 });
 
-Input.fromObject = function (obj) {
-  $.checkArgument(_.isObject(obj));
+/**
+ * Creates an Input instance from a plain JavaScript object.
+ * @param {Object} params - Input parameters object
+ * @param {string|Buffer} params.prevTxId - Previous transaction ID (hex string or Buffer)
+ * @param {number} params.outputIndex - Output index in previous transaction
+ * @param {Output} [params.output] - Output instance or output parameters
+ * @param {number} [params.sequenceNumber] - Sequence number (defaults to DEFAULT_SEQNUMBER)
+ * @param {Script|Buffer|string} [params.script] - Script instance, buffer or hex string
+ * @returns {Input} The created Input instance.
+ * @throws {Error} Will throw if the argument is not an object.
+ */
+Input.fromObject = function (params) {
+  $.checkArgument(_.isObject(params));
   var input = new Input();
-  return input._fromObject(obj);
+  return input._fromObject(params);
 };
 
+/**
+ * Creates an Input instance from an object containing transaction input parameters.
+ * Validates required fields (prevTxId, outputIndex) and converts hex strings to Buffers.
+ * Handles optional parameters with defaults (sequenceNumber, script).
+ * @param {Object} params - Input parameters object
+ * @param {string|Buffer} params.prevTxId - Previous transaction ID (hex string or Buffer)
+ * @param {number} params.outputIndex - Output index in previous transaction
+ * @param {Output} [params.output] - Output instance or output parameters
+ * @param {number} [params.sequenceNumber] - Sequence number (defaults to DEFAULT_SEQNUMBER)
+ * @param {Script|Buffer|string} [params.script] - Script instance, buffer or hex string
+ * @throws {errors.Transaction.Input.InvalidParams} If required params are missing
+ * @returns {Input} Returns the Input instance for chaining
+ * @private
+ */
 Input.prototype._fromObject = function (params) {
 
-  if(_.isUndefined(params.prevTxId) 
+  if(_.isUndefined(params.prevTxId)
     || _.isUndefined(params.outputIndex)) {
      throw new errors.Transaction.Input.InvalidParams('require prevTxId and outputIndex');
   }
@@ -100,6 +125,14 @@ Input.prototype._fromObject = function (params) {
   return this;
 };
 
+
+/**
+ * Converts the Input instance to a plain object for JSON serialization.
+ * Includes prevTxId, outputIndex, sequenceNumber, and script as hex strings.
+ * Optionally adds human-readable scriptString if script is valid,
+ * and includes the output object if present.
+ * @returns {Object} A plain object representation of the Input.
+ */
 Input.prototype.toObject = Input.prototype.toJSON = function toObject() {
   var obj = {
     prevTxId: this.prevTxId.toString('hex'),
@@ -117,6 +150,17 @@ Input.prototype.toObject = Input.prototype.toJSON = function toObject() {
   return obj;
 };
 
+/**
+ * Creates an Input instance from a BufferReader.
+ * @param {BufferReader} br - The buffer reader containing input data.
+ * @returns {Input} The parsed Input object with properties:
+ *   - prevTxId: Reversed 32-byte previous transaction ID.
+ *   - outputIndex: LE uint32 output index.
+ *   - _scriptBuffer: Var-length script buffer.
+ *   - sequenceNumber: LE uint32 sequence number.
+ * @note TODO: Return specialized input types (CoinbaseInput, PublicKeyHashInput, etc.).
+ * @static
+ */
 Input.fromBufferReader = function (br) {
   var input = new Input();
   input.prevTxId = br.readReverse(32);
@@ -128,6 +172,12 @@ Input.fromBufferReader = function (br) {
   return input;
 };
 
+/**
+ * Serializes the input to a BufferWriter.
+ * @param {boolean} hashScriptSig - Whether to hash the script (true) or include it directly (false).
+ * @param {BufferWriter} [writer] - Optional BufferWriter instance to write to.
+ * @returns {BufferWriter} The BufferWriter containing the serialized input.
+ */
 Input.prototype.toBufferWriter = function (hashScriptSig, writer) {
   $.checkArgument(typeof hashScriptSig === 'boolean', 'hashScriptSig should be boolean')
   if (!writer) {
@@ -147,6 +197,10 @@ Input.prototype.toBufferWriter = function (hashScriptSig, writer) {
 }
 
 
+/**
+ * Converts the input to a prevout format (txid + output index) as a buffer.
+ * @returns {Buffer} The serialized prevout data.
+ */
 Input.prototype.toPrevout = function () {
   let writer = new BufferWriter()
   writer.writeReverse(this.prevTxId)
@@ -155,6 +209,12 @@ Input.prototype.toPrevout = function () {
 }
 
 
+/**
+ * Sets the script for this input.
+ * @param {Script|string|Buffer|null} script - Can be a Script object, hex string, human-readable string, Buffer, or null (for empty script)
+ * @returns {Input} Returns the Input instance for chaining
+ * @throws {TypeError} If script is of invalid type
+ */
 Input.prototype.setScript = function (script) {
   this._script = null;
   if (script instanceof Script) {
@@ -189,7 +249,6 @@ Input.prototype.setScript = function (script) {
  * @param {PrivateKey | Array} privateKeys - the private key to use when signing
  * @param {number} inputIndex - the index of this input in the provided transaction
  * @param {number} sigType - defaults to Signature.SIGHASH_ALL
- * @abstract
  */
 Input.prototype.getSignatures = function (transaction, privateKeys, inputIndex, sigtype) {
   $.checkState(this.output instanceof Output);
@@ -246,37 +305,62 @@ Input.prototype.getSignatures = function (transaction, privateKeys, inputIndex,
  * @param {number} inputIndex - the index of this input in the provided transaction
  * @param {number} sigType - defaults to Signature.SIGHASH_ALL
  * @param {boolean} isLowS - true if the sig hash is safe for low s.
- * @abstract
  */
 Input.prototype.getPreimage = function (transaction, inputIndex, sigtype, isLowS) {
   $.checkState(this.output instanceof Output);
   sigtype = sigtype || Signature.SIGHASH_ALL;
   isLowS = isLowS || false;
   return isLowS
-    ? getLowSPreimage(transaction, sigtype, inputIndex)
+    ? Sighash.getLowSSighashPreimage(transaction, sigtype, inputIndex)
     : Sighash.sighashPreimage(transaction, sigtype, inputIndex);
 };
 
+/**
+ * Abstract method that throws an error when invoked. Must be implemented by subclasses
+ * to determine if all required signatures are present on this input.
+ * @throws {AbstractMethodInvoked} Always throws to indicate abstract method usage
+ * @abstract
+ */
 Input.prototype.isFullySigned = function () {
   throw new errors.AbstractMethodInvoked('Input#isFullySigned');
 };
 
+/**
+ * Checks if the input is final (has maximum sequence number).
+ * @returns {boolean} True if the input is final, false otherwise.
+ */
 Input.prototype.isFinal = function () {
   return this.sequenceNumber === Input.MAXINT;
 };
 
-Input.prototype.addSignature = function (transaction, signature) {
-  const s = Script.buildPublicKeyIn(signature.signature.toDER(), signature.sigtype)
-  console.log("s:", s.toHex())
-  // throw new errors.AbstractMethodInvoked('Input#addSignature')
+/**
+ * Abstract method to add a signature to the transaction input.
+ * Must be implemented by concrete input types.
+ * @param {Object} transaction - The transaction to sign
+ * @param {Object} signature - The signature to add
+ * @abstract
+ */
+Input.prototype.addSignature = function (_transaction, _signature) {
 };
 
+/**
+ * Clears all signatures from the input.
+ * @abstract
+ */
 Input.prototype.clearSignatures = function () {
-  // throw new errors.AbstractMethodInvoked('Input#clearSignatures')
+
 };
 
+/**
+ * Verifies if a signature is valid for this input in the given transaction.
+ * Note: Temporarily modifies the signature object by setting nhashtype from sigtype.
+ * 
+ * @param {Object} transaction - The transaction to verify against
+ * @param {TransactionSignature} signature - Signature object containing signature, publicKey, etc.
+ * @returns {boolean} True if the signature is valid, false otherwise
+ */
 Input.prototype.isValidSignature = function (transaction, signature) {
-  // FIXME: Refactor signature so this is not necessary
+// FIXME: Refactor signature so this is not necessary
   signature.signature.nhashtype = signature.sigtype;
   return Sighash.verify(
     transaction,
@@ -299,56 +383,14 @@ Input.prototype.isNull = function () {
   );
 };
 
+/**
+ * Estimates the size of the input in bytes by converting it to a buffer.
+ * @returns {number} The length of the serialized buffer in bytes.
+ * @private
+ */
 Input.prototype._estimateSize = function () {
   return this.toBufferWriter(false).toBuffer().length;
 };
 
-Input.prototype.verify = function (transaction, inputIndex) {
-  $.checkState(this.output instanceof Output);
-  $.checkState(this.script instanceof Script);
-  $.checkState(this.output.script instanceof Script);
-
-  var us = this.script;
-  var ls = this.output.script;
-  var inputSatoshis = this.output.satoshisBN;
-
-  Interpreter.MAX_SCRIPT_ELEMENT_SIZE = Number.MAX_SAFE_INTEGER;
-  Interpreter.MAXIMUM_ELEMENT_SIZE = Number.MAX_SAFE_INTEGER;
-
-  const bsi = new Interpreter();
-
-  let failedAt = {};
-
-  bsi.stepListener = function (step) {
-    if (
-      step.fExec ||
-      (Opcode.OP_IF <= step.opcode.toNumber() && step.opcode.toNumber() <= Opcode.OP_ENDIF)
-    ) {
-      if (
-        (Opcode.OP_IF <= step.opcode.toNumber() && step.opcode.toNumber() <= Opcode.OP_ENDIF) ||
-        step.opcode.toNumber() === Opcode.OP_RETURN
-      ) {
-        /** Opreturn */ failedAt.opcode = step.opcode;
-      } else {
-        failedAt = step;
-      }
-    }
-  };
-
-  var success = bsi.verify(
-    us,
-    ls,
-    transaction,
-    inputIndex,
-    Interpreter.DEFAULT_FLAGS,
-    inputSatoshis,
-  );
-
-  if (failedAt.opcode) {
-    failedAt.opcode = failedAt.opcode.toNumber();
-  }
-
-  return { success, error: bsi.errstr, failedAt: success ? {} : failedAt };
-};
 
-module.exports = Input;
+export default Input;