@opcat-labs/opcat 1.0.0 → 1.0.2

package/.cjs2esm.json

@@ -0,0 +1,18 @@
+{
+  "input": ["cjs"],
+  "ignore": [],
+  "output": "esm",
+  "forceDirectory": null,
+  "modules": [],
+  "extension": {
+    "use": "js",
+    "ignore": []
+  },
+  "addModuleEntry": false,
+  "addPackageJson": false,
+  "filesWithShebang": [],
+  "codemod": {
+    "path": "",
+    "files": ["cjs", "exports"]
+  }
+}

package/.mocharc.yaml

@@ -1,3 +1,3 @@
 recursive: true
 timeout: 5000
-spec: ['./test/**/*.js']
+spec: ['./test/**/*.cjs']

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @opcat-labs/opcat
+
+## 1.0.2
+
+### Patch Changes
+
+- fix esm, fix change amount, add decodePubFunctionCall
+
+## 1.0.1
+
+### Patch Changes
+
+- add cli project command

package/README.md

@@ -0,0 +1,6 @@
+opcat
+=====
+
+Javascript Opcat library.
+
+Documentation is available on the [Opcat Docs](http://docs.opcatlabs.io/overview).

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

@@ -1,16 +1,15 @@
 'use strict';
 
-var _ = require('./util/_');
-var $ = require('./util/preconditions');
-var errors = require('./errors');
-var Base58Check = require('./encoding/base58check');
-var Networks = require('./networks');
-var Hash = require('./crypto/hash');
-var JSUtil = require('./util/js');
-var PublicKey = require('./publickey');
+var _ = require('./util/_.cjs');
+var $ = require('./util/preconditions.cjs');
+var Base58Check = require('./encoding/base58check.cjs');
+var Networks = require('./networks.cjs');
+var Hash = require('./crypto/hash.cjs');
+var JSUtil = require('./util/js.cjs');
+
 /**
  * Instantiate an address from an address String or Buffer, a public key hash Buffer,
- * or an instance of {@link PublicKey}.
+ * or a {@link PublicKey} Buffer.
  *
  * This is an immutable class, and if the first parameter provided to this constructor is an
  * `Address` instance, the same argument will be returned.
@@ -37,8 +36,8 @@ var PublicKey = require('./publickey');
  * ```
  *
  * @param {*} data - The encoded data in various formats
- * @param {Network|String|number=} network - The network: 'livenet' or 'testnet'
- * @param {string=} type - The type of address: 'pubkey'
+ * @param {Network|String|number} [network] - The network: 'livenet' or 'testnet'
+ * @param {string} [type] - The type of address: 'pubkey'
  * @returns {Address} A new valid and frozen instance of an Address
  * @constructor
  */
@@ -81,24 +80,64 @@ function Address(data, network, type) {
   return this;
 }
 
+/**
+ * Gets the hash buffer of the Address instance.
+ * @memberof Address.prototype
+ * @type {Buffer}
+ * @readonly
+ */
+Object.defineProperty(Address.prototype, 'hashBuffer', {
+  enumerable: true,
+  configurable: false,
+  get: function () {
+    return this.hashBuffer;
+  },
+});
+
+/**
+ * Gets or sets the network associated with this Address instance.
+ * @memberof Address.prototype
+ * @type {Network}
+ * @readonly
+ */
+Object.defineProperty(Address.prototype, 'network', {
+  enumerable: true,
+  configurable: false,
+  get: function () {
+    return this.network;
+  },
+});
+
+/**
+ * Gets the address type (e.g. 'pubkeyhash').
+ * @memberof Address.prototype
+ * @type {string}
+ * @readonly
+ */
+Object.defineProperty(Address.prototype, 'type', {
+  enumerable: true,
+  configurable: false,
+  get: function () {
+    return this.type;
+  },
+});
+
 /**
  * Internal function used to split different kinds of arguments of the constructor
- * @param {*} data - The encoded data in various formats
- * @param {Network|String|number=} network - The network: 'livenet' or 'testnet'
- * @param {string=} type - The type of address: 'pubkey'
+ * @param {Buffer|Uint8Array|string|Object} data - The encoded data in various formats
+ * @param {Network|string} [network] - The network: 'livenet' or 'testnet'
+ * @param {string} [type] - The type of address: 'pubkey'
  * @returns {Object} An "info" object with "type", "network", and "hashBuffer"
+ * @private
  */
 Address.prototype._classifyArguments = function (data, network, type) {
-  var Script = require('./script');
   // transform and validate input data
   if ((data instanceof Buffer || data instanceof Uint8Array) && data.length === 20) {
     return Address._transformHash(data);
   } else if ((data instanceof Buffer || data instanceof Uint8Array) && data.length === 21) {
     return Address._transformBuffer(data, network, type);
-  } else if (data instanceof PublicKey) {
+  } else if ((data instanceof Buffer || data instanceof Uint8Array) && (data.length === 33 || data.length === 65)) {
     return Address._transformPublicKey(data);
-  } else if (data instanceof Script) {
-    return Address._transformScript(data, network);
   } else if (typeof data === 'string') {
     return Address._transformString(data, network, type);
   } else if (_.isObject(data)) {
@@ -108,7 +147,11 @@ Address.prototype._classifyArguments = function (data, network, type) {
   }
 };
 
-/** @static */
+/**
+ * PayToPublicKeyHash address type identifier.
+ * @type {string}
+ * @static
+ */
 Address.PayToPublicKeyHash = 'pubkeyhash';
 
 /**
@@ -135,6 +178,7 @@ Address._transformHash = function (hash) {
  * @param {string} data.type - either 'pubkeyhash' or 'scripthash'
  * @param {Network=} data.network - the name of the network associated
  * @return {Address}
+ * @private
  */
 Address._transformObject = function (data) {
   $.checkArgument(data.hash || data.hashBuffer, 'Must provide a `hash` or `hashBuffer` property');
@@ -215,31 +259,14 @@ Address._transformBuffer = function (buffer, network, type) {
  */
 Address._transformPublicKey = function (pubkey) {
   var info = {};
-  if (!(pubkey instanceof PublicKey)) {
-    throw new TypeError('Address must be an instance of PublicKey.');
+  if (!(pubkey instanceof Buffer) && !(pubkey instanceof Uint8Array) || (pubkey.length !== 33 && pubkey.length !== 65)) {
+    throw new TypeError('Pubkey supplied is not a buffer with 33 or 65 bytes.');
   }
-  info.hashBuffer = Hash.sha256ripemd160(pubkey.toBuffer());
+  info.hashBuffer = Hash.sha256ripemd160(pubkey);
   info.type = Address.PayToPublicKeyHash;
   return info;
 };
 
-/**
- * Internal function to transform a {@link Script} into a `info` object.
- *
- * @param {Script} script - An instance of Script
- * @returns {Object} An object with keys: hashBuffer, type
- * @private
- */
-Address._transformScript = function (script, network) {
-  var Script = require('./script');
-  $.checkArgument(script instanceof Script, 'script must be a Script instance');
-  var info = script.getAddressInfo(network);
-  if (!info) {
-    throw new errors.Script.CantDeriveAddress(script);
-  }
-  return info;
-};
-
 /**
  * Internal function to transform a bitcoin cash address string
  *
@@ -268,9 +295,9 @@ Address._transformString = function (data, network, type) {
 };
 
 /**
- * Instantiate an address from a PublicKey instance
+ * Instantiate an address from a PublicKey buffer
  *
- * @param {PublicKey} data
+ * @param {Buffer} data - A buffer of the public key
  * @param {String|Network} network - either a Network instance, 'livenet', or 'testnet'
  * @returns {Address} A new valid and frozen instance of an Address
  */
@@ -280,18 +307,6 @@ Address.fromPublicKey = function (data, network) {
   return new Address(info.hashBuffer, network, info.type);
 };
 
-/**
- * Instantiate an address from a PrivateKey instance
- *
- * @param {PrivateKey} privateKey
- * @param {String|Network} network - either a Network instance, 'livenet', or 'testnet'
- * @returns {Address} A new valid and frozen instance of an Address
- */
-Address.fromPrivateKey = function (privateKey, network) {
-  let publicKey = PublicKey.fromPrivateKey(privateKey);
-  network = network || privateKey.network || Networks.defaultNetwork;
-  return Address.fromPublicKey(publicKey, network);
-};
 
 /**
  * Instantiate an address from a ripemd160 public key hash
@@ -304,27 +319,10 @@ Address.fromPublicKeyHash = function (hash, network) {
   var info = Address._transformHash(hash);
   return new Address(info.hashBuffer, network, Address.PayToPublicKeyHash);
 };
-/**
- * Extract address from a Script. The script must be of one
- * of the following types: p2pkh input, p2pkh output, p2sh input
- * or p2sh output.
- * This will analyze the script and extract address information from it.
- * If you want to transform any script to a p2sh Address paying
- * to that script's hash instead, use {{Address#payingTo}}
- *
- * @param {Script} script - An instance of Script
- * @param {String|Network} network - either a Network instance, 'livenet', or 'testnet'
- * @returns {Address} A new valid and frozen instance of an Address
- */
-Address.fromScript = function (script, network) {
-  var Script = require('./script');
-  $.checkArgument(script instanceof Script, 'script must be a Script instance');
-  var info = Address._transformScript(script, network);
-  return new Address(info.hashBuffer, network, info.type);
-};
+
 
 /**
- * Instantiate an address from a buffer of the address
+ * Instantiate an address from a bitcoin address buffer
  *
  * @param {Buffer} buffer - An instance of buffer of the address
  * @param {String|Network=} network - either a Network instance, 'livenet', or 'testnet'
@@ -336,6 +334,13 @@ Address.fromBuffer = function (buffer, network, type) {
   return new Address(info.hashBuffer, info.network, info.type);
 };
 
+/**
+ * Creates an Address instance from a hex string.
+ * @param {string} hex - The hex string representation of the address.
+ * @param {Network} network - The network type (e.g., 'mainnet', 'testnet').
+ * @param {AddressType} [type] - Optional address type.
+ * @returns {Address} The Address instance created from the hex string.
+ */
 Address.fromHex = function (hex, network, type) {
   return Address.fromBuffer(Buffer.from(hex, 'hex'), network, type);
 };

package/cjs/block/block.cjs

@@ -0,0 +1,332 @@
+'use strict';
+
+var _ = require('../util/_.cjs');
+var BlockHeader = require('./blockheader.cjs');
+var MerkleBlock = require('./merkleblock.cjs');
+var BN = require('../crypto/bn.cjs');
+var BufferReader = require('../encoding/bufferreader.cjs');
+var BufferWriter = require('../encoding/bufferwriter.cjs');
+var Hash = require('../crypto/hash.cjs');
+var Transaction = require('../transaction/index.cjs');
+var $ = require('../util/preconditions.cjs');
+
+/**
+ * Instantiate a Block from a Buffer, JSON object, or Object with
+ * the properties of the Block
+ *
+ * @param {*} - A Buffer, JSON string, or Object
+ * @returns {Block}
+ * @constructor
+ */
+function Block(arg) {
+  if (!(this instanceof Block)) {
+    return new Block(arg);
+  }
+  _.extend(this, Block._from(arg));
+  return this;
+}
+
+/**
+ * The maximum allowed size (in bytes) for a block.
+ * @type {number}
+ */
+Block.MAX_BLOCK_SIZE = 128000000;
+
+
+/**
+ * Creates a Block instance from the given argument.
+ * @param {*} arg - The input to convert into a Block.
+ * @returns {Block} A new Block instance.
+ * @throws {TypeError} - If the argument was not recognized
+ * @private
+ */
+Block._from = function _from(arg) {
+  var info = {};
+  if (Buffer.isBuffer(arg)) {
+    info = Block._fromBufferReader(BufferReader(arg));
+  } else if (_.isObject(arg)) {
+    info = Block._fromObject(arg);
+  } else {
+    throw new TypeError('Unrecognized argument for Block');
+  }
+  return info;
+};
+
+
+/**
+ * Creates a Block instance from a plain object.
+ * @param {Object} data - The plain object containing block data.
+ * @returns {Block} The created Block instance.
+ * @private
+ */
+Block._fromObject = function _fromObject(data) {
+  var transactions = [];
+  data.transactions.forEach(function (tx) {
+    if (tx instanceof Transaction) {
+      transactions.push(tx);
+    } else {
+      transactions.push(Transaction().fromObject(tx));
+    }
+  });
+  var info = {
+    header: BlockHeader.fromObject(data.header),
+    transactions: transactions,
+  };
+  return info;
+};
+
+
+/**
+ * Creates a Block instance from a plain JavaScript object.
+ * @param {Object} obj - The source object to convert to a Block.
+ * @returns {Block} A new Block instance.
+ */
+Block.fromObject = function fromObject(obj) {
+  var info = Block._fromObject(obj);
+  return new Block(info);
+};
+
+
+/**
+ * Creates a Block instance from a BufferReader.
+ * @private
+ * @param {BufferReader} br - The buffer reader containing block data
+ * @returns {Block} The parsed Block instance
+ */
+Block._fromBufferReader = function _fromBufferReader(br) {
+  var info = {};
+  $.checkState(!br.finished(), 'No block data received');
+  info.header = BlockHeader.fromBufferReader(br);
+  var transactions = br.readVarintNum();
+  info.transactions = [];
+  for (var i = 0; i < transactions; i++) {
+    info.transactions.push(Transaction().fromBufferReader(br));
+  }
+  return info;
+};
+
+
+/**
+ * Creates a Block instance from a BufferReader.
+ * @param {BufferReader} br - The buffer reader containing block data.
+ * @returns {Block} The parsed Block instance.
+ */
+Block.fromBufferReader = function fromBufferReader(br) {
+  $.checkArgument(br, 'br is required');
+  var info = Block._fromBufferReader(br);
+  return new Block(info);
+};
+
+
+/**
+ * Creates a Block instance from a buffer.
+ * @param {Buffer} buf - The input buffer to create the block from.
+ * @returns {Block} The created Block instance.
+ */
+Block.fromBuffer = function fromBuffer(buf) {
+  return Block.fromBufferReader(new BufferReader(buf));
+};
+
+
+/**
+ * Creates a Block instance from a string representation.
+ * @param {string} str - The string to parse into a Block.
+ * @returns {Block} The parsed Block instance.
+ */
+Block.fromString = function fromString(str) {
+  var buf = Buffer.from(str, 'hex');
+  return Block.fromBuffer(buf);
+};
+
+
+/**
+ * Creates a Block instance from raw block data.
+ * @param {Object} data - The raw block data to convert.
+ * @returns {Block} A new Block instance.
+ */
+Block.fromRawBlock = function fromRawBlock(data) {
+  if (!Buffer.isBuffer(data)) {
+    data = Buffer.from(data, 'binary');
+  }
+  var br = BufferReader(data);
+  br.pos = Block.Values.START_OF_BLOCK;
+  var info = Block._fromBufferReader(br);
+  return new Block(info);
+};
+
+
+/**
+ * Converts the Block instance to a plain object (also aliased as toJSON).
+ * @returns {Object} The plain object representation of the Block.
+ */
+Block.prototype.toObject = Block.prototype.toJSON = function toObject() {
+  var transactions = [];
+  this.transactions.forEach(function (tx) {
+    transactions.push(tx.toObject());
+  });
+  return {
+    header: this.header.toObject(),
+    transactions: transactions,
+  };
+};
+
+
+/**
+ * Converts the block to a buffer representation.
+ * @returns {Buffer} The buffer containing the block data.
+ */
+Block.prototype.toBuffer = function toBuffer() {
+  return this.toBufferWriter().concat();
+};
+
+/**
+ * Returns the string representation of the Block instance.
+ * @returns {string} - A hex encoded string of the block
+ */
+Block.prototype.toString = function toString() {
+  return this.toBuffer().toString('hex');
+};
+
+/**
+ * @param {BufferWriter} - An existing instance of BufferWriter
+ * @returns {BufferWriter} - An instance of BufferWriter representation of the Block
+ */
+Block.prototype.toBufferWriter = function toBufferWriter(bw) {
+  if (!bw) {
+    bw = new BufferWriter();
+  }
+  bw.write(this.header.toBuffer());
+  bw.writeVarintNum(this.transactions.length);
+  for (var i = 0; i < this.transactions.length; i++) {
+    this.transactions[i].toBufferWriter(false, bw);
+  }
+  return bw;
+};
+
+/**
+ * Will iterate through each transaction and return an array of hashes
+ * @returns {Array} - An array with transaction hashes
+ */
+Block.prototype.getTransactionHashes = function getTransactionHashes() {
+  var hashes = [];
+  if (this.transactions.length === 0) {
+    return [Block.Values.NULL_HASH];
+  }
+  for (var t = 0; t < this.transactions.length; t++) {
+    hashes.push(this.transactions[t]._getHash());
+  }
+  return hashes;
+};
+
+/**
+ * Will build a merkle tree of all the transactions, ultimately arriving at
+ * a single point, the merkle root.
+ * @link https://en.bitcoin.it/wiki/Protocol_specification#Merkle_Trees
+ * @returns {Array} - An array with each level of the tree after the other.
+ */
+Block.prototype.getMerkleTree = function getMerkleTree() {
+  var tree = this.getTransactionHashes();
+
+  var j = 0;
+  for (var size = this.transactions.length; size > 1; size = Math.floor((size + 1) / 2)) {
+    for (var i = 0; i < size; i += 2) {
+      var i2 = Math.min(i + 1, size - 1);
+      var buf = Buffer.concat([tree[j + i], tree[j + i2]]);
+      tree.push(Hash.sha256sha256(buf));
+    }
+    j += size;
+  }
+
+  return tree;
+};
+
+/**
+ * Calculates the merkleRoot from the transactions.
+ * @returns {Buffer} - A buffer of the merkle root hash
+ */
+Block.prototype.getMerkleRoot = function getMerkleRoot() {
+  var tree = this.getMerkleTree();
+  return tree[tree.length - 1];
+};
+
+/**
+ * Verifies that the transactions in the block match the header merkle root
+ * @returns {Boolean} - If the merkle roots match
+ */
+Block.prototype.validMerkleRoot = function validMerkleRoot() {
+  var h = new BN(this.header.merkleRoot.toString('hex'), 'hex');
+  var c = new BN(this.getMerkleRoot().toString('hex'), 'hex');
+
+  if (h.cmp(c) !== 0) {
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * @returns {Buffer} - The little endian hash buffer of the header
+ */
+Block.prototype._getHash = function () {
+  return this.header._getHash();
+};
+
+var idProperty = {
+  configurable: false,
+  enumerable: true,
+  /**
+   * @returns {string} - The big endian hash buffer of the header
+   */
+  get: function () {
+    if (!this._id) {
+      this._id = this.header.id;
+    }
+    return this._id;
+  },
+  set: _.noop,
+};
+/**
+ * Defines the `id` property on the Block prototype using the provided `idProperty` descriptor.
+ * @memberof Block.prototype
+ * @name id
+ */
+Object.defineProperty(Block.prototype, 'id', idProperty);
+/**
+ * Defines a property 'hash' on Block.prototype using idProperty as the descriptor.
+ * @memberof Block.prototype
+ * @name hash
+ */
+Object.defineProperty(Block.prototype, 'hash', idProperty);
+
+/**
+ * @returns {string} - A string formatted for the console
+ */
+Block.prototype.inspect = function inspect() {
+  return '<Block ' + this.id + '>';
+};
+
+/**
+ * Object containing constant values used by the Block module.
+ * @namespace Block.Values
+ */
+Block.Values = {
+  START_OF_BLOCK: 8, // Start of block in raw block data
+  NULL_HASH: Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex'),
+};
+
+
+/**
+ * Assigns the BlockHeader class to the Block namespace.
+ * @memberof Block
+ * @name BlockHeader
+ */
+Block.BlockHeader = BlockHeader;
+
+/**
+ * Assigns the MerkleBlock class to the Block namespace.
+ * @memberof Block
+ * @name MerkleBlock
+ */
+Block.MerkleBlock = MerkleBlock;
+
+module.exports = Block;

package/{lib/block/blockheader.js → cjs/block/blockheader.cjs}

@@ -1,11 +1,11 @@
 'use strict';
 
-var _ = require('../util/_');
-var BN = require('../crypto/bn');
-var BufferReader = require('../encoding/bufferreader');
-var BufferWriter = require('../encoding/bufferwriter');
-var Hash = require('../crypto/hash');
-var $ = require('../util/preconditions');
+var _ = require('../util/_.cjs');
+var BN = require('../crypto/bn.cjs');
+var BufferReader = require('../encoding/bufferreader.cjs');
+var BufferWriter = require('../encoding/bufferwriter.cjs');
+var Hash = require('../crypto/hash.cjs');
+var $ = require('../util/preconditions.cjs');
 
 var GENESIS_BITS = 0x1d00ffff;
 
@@ -17,7 +17,7 @@ var GENESIS_BITS = 0x1d00ffff;
  * @returns {BlockHeader} - An instance of block header
  * @constructor
  */
-var BlockHeader = function BlockHeader(arg) {
+function BlockHeader(arg) {
   if (!(this instanceof BlockHeader)) {
     return new BlockHeader(arg);
   }
@@ -232,6 +232,7 @@ BlockHeader.prototype.getDifficulty = function getDifficulty() {
 
 /**
  * @returns {Buffer} - The little endian hash buffer of the header
+ * @private
  */
 BlockHeader.prototype._getHash = function hash() {
   var buf = this.toBuffer();

package/cjs/block/index.cjs

@@ -0,0 +1,2 @@
+var Block = require('./block.cjs');
+module.exports = Block