@opcat-labs/opcat 1.0.1 → 1.0.3

package/{lib/script/stack.js → cjs/interpreter/stack.cjs}

@@ -1,11 +1,16 @@
 'use strict';
 
-var Stack = function Stack(rawstack, varStack) {
+/**
+ * Represents a stack structure with optional variable stack support.
+ * @constructor
+ * @param {Array} rawstack - The initial stack array
+ * @param {Array} [varStack] - Optional variable stack array
+ */
+function Stack(rawstack, varStack) {
   this.stack = rawstack;
   this.varStack = varStack || [];
 };
 
-module.exports = Stack;
 
 Stack.prototype.pushVar = function (varName) {
   this.varStack.push(varName || '$tmp');
@@ -107,3 +112,5 @@ Object.defineProperty(Stack.prototype, 'rawstack', {
     return this.stack;
   },
 });
+
+module.exports = Stack;

package/{lib/message/message.js → cjs/message/message.cjs}

@@ -1,23 +1,25 @@
 'use strict';
 
-var _ = require('../util/_');
-var PrivateKey = require('../privatekey');
-var PublicKey = require('../publickey');
-var Address = require('../address');
-var BufferWriter = require('../encoding/bufferwriter');
-var ECDSA = require('../crypto/ecdsa');
-var Signature = require('../crypto/signature');
-var sha256sha256 = require('../crypto/hash').sha256sha256;
-var JSUtil = require('../util/js');
-var $ = require('../util/preconditions');
+var _ = require('../util/_.cjs');
+var PrivateKey = require('../privatekey.cjs');
+var PublicKey = require('../publickey.cjs');
+var Address = require('../address.cjs');
+var BufferWriter = require('../encoding/bufferwriter.cjs');
+var ECDSA = require('../crypto/ecdsa.cjs');
+var Signature = require('../crypto/signature.cjs');
+var Hash = require('../crypto/hash.cjs');
+var JSUtil = require('../util/js.cjs');
+var $ = require('../util/preconditions.cjs');
+
 
 /**
- * constructs a new message to sign and verify.
- *
- * @param {String} message
- * @returns {Message}
+ * Creates a Message instance from a string or Buffer.
+ * @constructor
+ * @param {string|Buffer} message - The message content as either a string or Buffer
+ * @throws {Error} Will throw if message is not a string or Buffer
+ * @returns {Message} A new Message instance containing the message buffer
  */
-var Message = function Message(message) {
+function Message(message) {
   if (!(this instanceof Message)) {
     return new Message(message);
   }
@@ -37,6 +39,12 @@ var Message = function Message(message) {
   return this;
 };
 
+/**
+ * Signs a message with the given private key.
+ * @param {string|Buffer} message - The message to sign.
+ * @param {PrivateKey} privateKey - The private key used for signing.
+ * @returns {Message} The signed message instance.
+ */
 Message.sign = function (message, privateKey) {
   return new Message(message).sign(privateKey);
 };
@@ -47,14 +55,26 @@ Message.verify = function (message, address, signature) {
 
 Message.MAGIC_BYTES = Buffer.from('Bitcoin Signed Message:\n');
 
+/**
+ * Calculates the magic hash for the message by concatenating magic bytes prefixes
+ * with the message buffer and computing a double SHA-256 hash.
+ * @returns {Buffer} The resulting 32-byte hash.
+ */
 Message.prototype.magicHash = function magicHash() {
   var prefix1 = BufferWriter.varintBufNum(Message.MAGIC_BYTES.length);
   var prefix2 = BufferWriter.varintBufNum(this.messageBuffer.length);
   var buf = Buffer.concat([prefix1, Message.MAGIC_BYTES, prefix2, this.messageBuffer]);
-  var hash = sha256sha256(buf);
+  var hash = Hash.sha256sha256(buf);
   return hash;
 };
 
+/**
+ * Signs the message with the provided private key.
+ * @private
+ * @param {PrivateKey} privateKey - The private key instance to sign with.
+ * @returns {Buffer} The signature generated using ECDSA.
+ * @throws {Error} If the first argument is not a PrivateKey instance.
+ */
 Message.prototype._sign = function _sign(privateKey) {
   $.checkArgument(
     privateKey instanceof PrivateKey,
@@ -75,6 +95,13 @@ Message.prototype.sign = function sign(privateKey) {
   return signature.toCompact().toString('base64');
 };
 
+/**
+ * Verifies the message signature using the provided public key.
+ * @param {PublicKey} publicKey - The public key to verify against
+ * @param {Signature} signature - The signature to verify
+ * @returns {boolean} True if signature is valid, false otherwise
+ * @throws {Error} If arguments are not valid PublicKey/Signature instances
+ */
 Message.prototype._verify = function _verify(publicKey, signature) {
   $.checkArgument(
     publicKey instanceof PublicKey,
@@ -115,7 +142,7 @@ Message.prototype.verify = function verify(bitcoinAddress, signatureString) {
   ecdsa.sig = signature;
   var publicKey = ecdsa.toPublicKey();
 
-  var signatureAddress = Address.fromPublicKey(publicKey, bitcoinAddress.network);
+  var signatureAddress = Address.fromPublicKey(publicKey.toBuffer(), bitcoinAddress.network);
 
   // check that the recovered address and specified address match
   if (bitcoinAddress.toString() !== signatureAddress.toString()) {
@@ -149,8 +176,10 @@ Message.fromJSON = function fromJSON(json) {
   return Message.fromObject(json);
 };
 
+
 /**
- * @returns {Object} A plain object with the message information
+ * Converts the message to a plain object with hex representation.
+ * @returns {Object} An object containing the hex string of the message buffer.
  */
 Message.prototype.toObject = function toObject() {
   return {
@@ -158,31 +187,39 @@ Message.prototype.toObject = function toObject() {
   };
 };
 
+/**
+ * Creates a Message instance from an object containing a hex-encoded message.
+ * @param {Object} obj - The source object containing the message data.
+ * @param {string} obj.messageHex - Hex-encoded message string.
+ * @returns {Message} A new Message instance created from the decoded buffer.
+ */
 Message.fromObject = function (obj) {
   let messageBuffer = Buffer.from(obj.messageHex, 'hex');
   return new Message(messageBuffer);
 };
 
+
 /**
- * @returns {String} A JSON representation of the message information
+ * Converts the Message instance to a JSON string representation.
+ * @returns {string} The JSON string representation of the Message object.
  */
 Message.prototype.toJSON = function toJSON() {
   return JSON.stringify(this.toObject());
 };
 
+
 /**
- * Will return a the string representation of the message
- *
- * @returns {String} Message
+ * Converts the message buffer to a string representation.
+ * @returns {string} The string representation of the message buffer.
  */
 Message.prototype.toString = function () {
   return this.messageBuffer.toString();
 };
 
+
 /**
- * Will return a string formatted for the console
- *
- * @returns {String} Message
+ * Custom inspect method for Message instances.
+ * @returns {string} String representation in format '<Message: [content]>'.
  */
 Message.prototype.inspect = function () {
   return '<Message: ' + this.toString() + '>';

package/cjs/mnemonic/index.cjs

@@ -0,0 +1,3 @@
+var Mnemonic = require('./mnemonic.cjs');
+
+module.exports = Mnemonic

package/{lib/mnemonic/mnemonic.js → cjs/mnemonic/mnemonic.cjs}

@@ -1,15 +1,17 @@
 'use strict';
-var BN = require('../crypto/bn');
-var Hash = require('../crypto/hash');
-var Random = require('../crypto/random');
+var BN = require('../crypto/bn.cjs');
+var Hash = require('../crypto/hash.cjs');
+var Random = require('../crypto/random.cjs');
 var unorm = require('unorm');
-var _ = require('../util/_');
+var _ = require('../util/_.cjs');
 
-var pbkdf2 = require('./pbkdf2');
-var errors = require('../errors');
+var pbkdf2 = require('./pbkdf2.cjs');
+var errors = require('../errors/index.cjs');
+
+var $ = require('../util/preconditions.cjs');
+var HDPrivateKey = require('../hdprivatekey.cjs');
+var Words = require('./words/index.cjs');
 
-var $ = require('../util/preconditions');
-var HDPrivateKey = require('../hdprivatekey');
 
 /**
  * This is an immutable class that represents a BIP39 Mnemonic code.
@@ -27,12 +29,16 @@ var HDPrivateKey = require('../hdprivatekey');
  * var mnemonic = new Mnemonic(Mnemonic.Words.SPANISH);
  * var xprivkey = mnemonic.toHDPrivateKey();
  *
- * @param {*=} data - a seed, phrase, or entropy to initialize (can be skipped)
- * @param {Array=} wordlist - the wordlist to generate mnemonics from
+ * @param {Buffer|string|number} [data] - Input data (Buffer for seed, string for phrase, or number for entropy bits)
+ * @param {Array} [wordlist] - Optional wordlist for phrase generation/validation
+ * @throws {InvalidArgument} If invalid data type provided
+ * @throws {Mnemonic.UnknownWordlist} If phrase language can't be detected
+ * @throws {Mnemonic.InvalidMnemonic} If phrase is invalid
+ * @throws {InvalidArgument} If invalid ENT value (must be >=128 and divisible by 32)
  * @returns {Mnemonic} A new instance of Mnemonic
  * @constructor
  */
-var Mnemonic = function (data, wordlist) {
+function Mnemonic (data, wordlist) {
   if (!(this instanceof Mnemonic)) {
     return new Mnemonic(data, wordlist);
   }
@@ -87,16 +93,25 @@ var Mnemonic = function (data, wordlist) {
   });
 };
 
+/**
+ * Creates a new Mnemonic instance with random entropy using the specified wordlist.
+ * @param {Array} [wordlist=Mnemonic.Words.ENGLISH] - The wordlist to use for mnemonic generation (defaults to English).
+ * @returns {Mnemonic} A new Mnemonic instance with random entropy.
+ */
 Mnemonic.fromRandom = function (wordlist = Mnemonic.Words.ENGLISH) {
   return new Mnemonic(wordlist);
 };
 
+/**
+ * Creates a Mnemonic instance from a mnemonic string.
+ * @param {string} mnemonic - The mnemonic phrase string.
+ * @param {string} [wordlist=Mnemonic.Words.ENGLISH] - Optional wordlist (defaults to English).
+ * @returns {Mnemonic} A new Mnemonic instance.
+ */
 Mnemonic.fromString = function (mnemonic, wordlist = Mnemonic.Words.ENGLISH) {
   return new Mnemonic(mnemonic, wordlist);
 };
 
-Mnemonic.Words = require('./words');
-
 /**
  * Will return a boolean if the mnemonic is valid
  *
@@ -142,6 +157,7 @@ Mnemonic.isValid = function (mnemonic, wordlist) {
  * @param {String} mnemonic - The mnemonic string
  * @param {String} wordlist - The wordlist
  * @returns {boolean}
+ * @private
  */
 Mnemonic._belongsToWordlist = function (mnemonic, wordlist) {
   var words = unorm.nfkd(mnemonic).split(' ');
@@ -157,6 +173,7 @@ Mnemonic._belongsToWordlist = function (mnemonic, wordlist) {
  *
  * @param {String} mnemonic - The mnemonic string
  * @returns {Array} the wordlist or null
+ * @private
  */
 Mnemonic._getDictionary = function (mnemonic) {
   if (!mnemonic) return null;
@@ -239,6 +256,7 @@ Mnemonic.prototype.inspect = function () {
  * @param {Number} ENT - Entropy size, defaults to 128
  * @param {Array} wordlist - Array of words to generate the mnemonic
  * @returns {String} Mnemonic string
+ * @private
  */
 Mnemonic._mnemonic = function (ENT, wordlist) {
   var buf = Random.getRandomBuffer(ENT / 8);
@@ -251,6 +269,7 @@ Mnemonic._mnemonic = function (ENT, wordlist) {
  * @param {Number} entropy - Entropy buffer
  * @param {Array} wordlist - Array of words to generate the mnemonic
  * @returns {String} Mnemonic string
+ * @private
  */
 Mnemonic._entropy2mnemonic = function (entropy, wordlist) {
   var bin = '';
@@ -299,5 +318,17 @@ Mnemonic._entropyChecksum = function (entropy) {
 
   return checksum;
 };
+/**
+ * The list of valid mnemonic words used by the Mnemonic class.
+ * @type {Words}
+ */
+Mnemonic.Words = Words;
+
+/**
+ * Assigns the pbkdf2 function to Mnemonic.pbkdf2 for key derivation.
+ * @type {Function}
+ */
+Mnemonic.pbkdf2 = pbkdf2;
 
 module.exports = Mnemonic;
+

package/{lib/mnemonic/pbkdf2.node.js → cjs/mnemonic/pbkdf2.cjs}

@@ -3,9 +3,16 @@
 var crypto = require('crypto');
 
 /**
- * PDKBF2
+ * PDKBF2: Derives a key using PBKDF2 (Password-Based Key Derivation Function 2) with HMAC-SHA512.
  * Credit to: https://github.com/stayradiated/pbkdf2-sha512
- * Copyright (c) 2014, JP Richardson Copyright (c) 2010-2011 Intalio Pte, All Rights Reserved
+ *
+ * @param {string|Buffer} key - The input key/password (as string or Buffer)
+ * @param {string|Buffer} salt - The salt value (as string or Buffer)
+ * @param {number} iterations - Number of iterations to perform
+ * @param {number} dkLen - Desired length of the derived key in bytes
+ * @returns {Buffer} Derived key as Buffer
+ * @throws {TypeError} If key or salt are not strings or Buffers
+ * @throws {Error} If requested key length is too long
  */
 function pbkdf2(key, salt, iterations, dkLen) {
   var hLen = 64; // SHA512 Mac length

package/cjs/mnemonic/words/index.cjs

@@ -0,0 +1,66 @@
+var chinese = require('./chinese.cjs');
+var english = require('./english.cjs');
+var french = require('./french.cjs');
+var italian = require('./italian.cjs');
+var japanese = require('./japanese.cjs');
+var spanish = require('./spanish.cjs');
+
+
+/**
+ * Represents a collection of words for mnemonic purposes.
+ * @constructor
+ */
+function Words() {
+
+}
+
+/**
+ * Chinese word list for mnemonic generation.
+ * @memberof Words
+ * @type {string[]}
+ * @name CHINESE
+ */
+Words.CHINESE = chinese;
+
+/**
+ * English word list for mnemonic generation.
+ * @memberof Words
+ * @type {string[]}
+ * @name ENGLISH
+ */
+Words.ENGLISH = english;
+
+/**
+ * French word list for mnemonic generation.
+ * @memberof Words
+ * @type {string[]}
+ * @name FRENCH
+ */
+Words.FRENCH = french;
+
+
+/**
+ * Italian word list for mnemonic generation.
+ * @memberof Words
+ * @type {string[]}
+ * @name ITALIAN
+ */
+Words.ITALIAN = italian;
+
+/**
+ * Japanese word list for mnemonic generation.
+ * @memberof Words
+ * @type {string[]}
+ * @name JAPANESE
+ */
+Words.JAPANESE = japanese;
+
+/**
+ * Spanish word list for mnemonic generation.
+ * @memberof Words
+ * @type {string[]}
+ * @name SPANISH
+ */
+Words.SPANISH = spanish;
+
+module.exports = Words;

package/cjs/network.cjs

@@ -0,0 +1,13 @@
+/**
+ * A network is merely a map containing values that correspond to version
+ * numbers for each bitcoin network. Currently only supporting "livenet"
+ * (a.k.a. "mainnet"), "testnet", "regtest".
+ * @constructor
+ */
+function Network() { }
+
+Network.prototype.toString = function toString() {
+    return this.name;
+};
+
+module.exports = Network