@opcat-labs/opcat 1.0.1 → 1.0.2

package/esm/transaction/unspentoutput.js

@@ -0,0 +1,112 @@
+'use strict';
+
+import _ from '../util/_.js';
+import $ from '../util/preconditions.js';
+import JSUtil from '../util/js.js';
+import Script from '../script/index.js';
+import Address from '../address.js';
+
+/**
+ * Represents an unspent output information: its script, associated amount and address,
+ * transaction id and output index.
+ *
+ * @constructor
+ * @param {object} data
+ * @param {string} data.txid the previous transaction id
+ * @param {string=} data.txId alias for `txid`
+ * @param {number} data.vout the index in the transaction
+ * @param {number=} data.outputIndex alias for `vout`
+ * @param {string|Script} data.scriptPubKey the script that must be resolved to release the funds
+ * @param {string|Script=} data.script alias for `scriptPubKey`
+ * @param {number} data.amount amount of bitcoins associated
+ * @param {number=} data.satoshis alias for `amount`, but expressed in satoshis (1 OPCAT = 1e8 satoshis)
+ * @param {string|Address=} data.address the associated address to the script, if provided
+ */
+function UnspentOutput(data) {
+  if (!(this instanceof UnspentOutput)) {
+    return new UnspentOutput(data);
+  }
+  $.checkArgument(_.isObject(data), 'Must provide an object from where to extract data');
+  var address = data.address ? new Address(data.address) : undefined;
+  var txId = data.txid ? data.txid : data.txId;
+  if (!txId || !JSUtil.isHexaString(txId) || txId.length > 64) {
+    // TODO: Use the errors library
+    throw new Error('Invalid TXID in object', data);
+  }
+  var outputIndex = _.isUndefined(data.vout) ? data.outputIndex : data.vout;
+  if (!_.isNumber(outputIndex)) {
+    throw new Error('Invalid outputIndex, received ' + outputIndex);
+  }
+  $.checkArgument(
+    !_.isUndefined(data.scriptPubKey) || !_.isUndefined(data.script),
+    'Must provide the scriptPubKey for that output!',
+  );
+  var script = new Script(data.scriptPubKey || data.script);
+  $.checkArgument(
+    !_.isUndefined(data.amount) || !_.isUndefined(data.satoshis),
+    'Must provide an amount for the output',
+  );
+  var amount = !_.isUndefined(data.amount) ? Math.round(data.amount * 1e8) : data.satoshis;
+  var outputData = !_.isUndefined(data.data) ? Buffer.from(data.data, 'hex') : Buffer.from([])
+  $.checkArgument(_.isNumber(amount), 'Amount must be a number');
+  JSUtil.defineImmutable(this, {
+    address: address,
+    txId: txId,
+    outputIndex: outputIndex,
+    script: script,
+    satoshis: amount,
+    data: outputData,
+  });
+}
+
+/**
+ * Provide an informative output when displaying this object in the console
+ * @returns string
+ */
+UnspentOutput.prototype.inspect = function () {
+  return (
+    '<UnspentOutput: ' +
+    this.txId +
+    ':' +
+    this.outputIndex +
+    ', satoshis: ' +
+    this.satoshis +
+    ', address: ' +
+    this.address +
+    '>'
+  );
+};
+
+/**
+ * String representation: just "txid:index"
+ * @returns string
+ */
+UnspentOutput.prototype.toString = function () {
+  return this.txId + ':' + this.outputIndex;
+};
+
+/**
+ * Deserialize an UnspentOutput from an object
+ * @param {object|string} data
+ * @return UnspentOutput
+ */
+UnspentOutput.fromObject = function (data) {
+  return new UnspentOutput(data);
+};
+
+/**
+ * Returns a plain object (no prototype or methods) with the associated info for this output
+ * @return {object}
+ */
+UnspentOutput.prototype.toObject = UnspentOutput.prototype.toJSON = function toObject() {
+  return {
+    address: this.address ? this.address.toString() : undefined,
+    txid: this.txId,
+    vout: this.outputIndex,
+    scriptPubKey: this.script.toBuffer().toString('hex'),
+    amount: Number.parseFloat((this.satoshis / 1e8).toFixed(8)),
+    data: this.data.toString('hex')
+  };
+};
+
+export default UnspentOutput;

package/esm/util/_.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var _ = {};
+
+_.isArray = (t) => Array.isArray(t);
+_.isNumber = (t) => typeof t === 'number';
+_.isObject = (t) => t && typeof t === 'object';
+_.isString = (t) => typeof t === 'string';
+_.isUndefined = (t) => typeof t === 'undefined';
+_.isFunction = (t) => typeof t === 'function';
+_.isNull = (t) => t === null;
+_.isDate = (t) => t instanceof Date;
+_.extend = (a, b) => Object.assign(a, b);
+_.noop = () => {};
+_.every = (a, f) => a.every(f || ((t) => t));
+_.map = (a, f) => Array.from(a).map(f || ((t) => t));
+_.includes = (a, e) => a.includes(e);
+_.each = (a, f) => a.forEach(f);
+_.clone = (o) => Object.assign({}, o);
+_.pick = (object, keys) => {
+  const obj = {};
+  keys.forEach((key) => {
+    if (typeof object[key] !== 'undefined') {
+      obj[key] = object[key];
+    }
+  });
+  return obj;
+};
+_.values = (o) => Object.values(o);
+_.filter = (a, f) => a.filter(f);
+_.reduce = (a, f, s) => a.reduce(f, s);
+_.without = (a, n) => a.filter((t) => t !== n);
+_.shuffle = (a) => {
+  const result = a.slice(0);
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+};
+_.difference = (a, b) => a.filter((t) => !b.includes(t));
+_.findIndex = (a, f) => a.findIndex(f);
+_.some = (a, f) => a.some(f);
+_.range = (n) => [...Array(n).keys()];
+_.isPositiveNumber = (n) => n < 0x7e;
+
+export default _;

package/esm/util/derivation.js

@@ -0,0 +1,53 @@
+
+import _ from './_.js';
+
+/**
+ * Represents a derivation function or class (purpose to be determined based on implementation).
+ * @constructor
+ */
+function Derivation() {
+}
+
+Derivation.RootElementAlias = ['m', 'M', "m'", "M'"]
+Derivation.Hardened = 0x80000000;
+
+/**
+ * function that splits a string path into a derivation index array.
+ * It will return null if the string path is malformed.
+ * It does not validate if indexes are in bounds.
+ *
+ * @param {string} path
+ * @return {Array}
+ */
+Derivation.getDerivationIndexes = function getDerivationIndexes(path) {
+var steps = path.split('/');
+
+  // Special cases:
+  if (_.includes(Derivation.RootElementAlias, path)) {
+    return [];
+  }
+
+  if (!_.includes(Derivation.RootElementAlias, steps[0])) {
+    return null;
+  }
+
+  var indexes = steps.slice(1).map(function (step) {
+    var isHardened = step.slice(-1) === "'";
+    if (isHardened) {
+      step = step.slice(0, -1);
+    }
+    if (!step || step[0] === '-') {
+      return NaN;
+    }
+    var index = +step; // cast to number
+    if (isHardened) {
+      index += Derivation.Hardened;
+    }
+
+    return index;
+  });
+
+  return _.some(indexes, isNaN) ? null : indexes;
+}
+
+export default Derivation;

package/esm/util/index.js

@@ -0,0 +1,12 @@
+import js from './js.js';
+import preconditions from './preconditions.js';
+import _ from './_.js';
+import derivation from './derivation.js';
+
+export default {
+    js,
+    preconditions,
+    _,
+    derivation,
+};
+

package/esm/util/js.js

@@ -0,0 +1,95 @@
+'use strict';
+
+import _ from './_.js';
+import $ from './preconditions.js';
+
+/**
+ * Utility functions for JavaScript operations.
+ * @constructor
+ */
+function JSUtil() {
+}
+
+/**
+ * Determines whether a string contains only hexadecimal values
+ *
+ * @name JSUtil.isHexa
+ * @param {string} value
+ * @return {boolean} true if the string is the hexa representation of a number
+ */
+JSUtil.isHexa = function isHexa(value) {
+  if (!_.isString(value)) {
+    return false;
+  }
+  return /^[0-9a-fA-F]+$/.test(value);
+};
+
+JSUtil.isHexaString = JSUtil.isHexa;
+
+/**
+ * Checks that a value is a natural number, a positive integer or zero.
+ *
+ * @param {*} value
+ * @return {Boolean}
+ */
+JSUtil.isNaturalNumber = function isNaturalNumber(value) {
+  return (
+    typeof value === 'number' && isFinite(value) && Math.floor(value) === value && value >= 0
+  );
+}
+
+/**
+* Transform a 4-byte integer (unsigned value) into a Buffer of length 4 (Big Endian Byte Order)
+*
+* @param {number} integer
+* @return {Buffer}
+*/
+JSUtil.integerAsBuffer = function integerAsBuffer(integer) {
+  $.checkArgumentType(integer, 'number', 'integer');
+  const buf = Buffer.allocUnsafe(4);
+  buf.writeUInt32BE(integer, 0);
+  return buf;
+}
+
+/**
+ * Test if an argument is a valid JSON object. If it is, returns a truthy
+ * value (the json object decoded), so no double JSON.parse call is necessary
+ *
+ * @param {string} arg
+ * @return {Object|boolean} false if the argument is not a JSON string.
+ */
+JSUtil.isValidJSON = function isValidJSON(arg) {
+  var parsed;
+  if (!_.isString(arg)) {
+    return false;
+  }
+  try {
+    parsed = JSON.parse(arg);
+  } catch (e) {
+    return false;
+  }
+  if (typeof parsed === 'object') {
+    return true;
+  }
+  return false;
+}
+
+/**
+   * Define immutable properties on a target object
+   *
+   * @param {Object} target - An object to be extended
+   * @param {Object} values - An object of properties
+   * @return {Object} The target object
+   */
+JSUtil.defineImmutable = function defineImmutable(target, values) {
+  Object.keys(values).forEach(function (key) {
+    Object.defineProperty(target, key, {
+      configurable: false,
+      enumerable: true,
+      value: values[key],
+    });
+  });
+  return target;
+}
+
+export default JSUtil;

package/esm/util/preconditions.js

@@ -0,0 +1,33 @@
+'use strict';
+
+import errors from '../errors/index.js';
+import _ from './_.js';
+
+export default {
+  checkState: function (condition, message) {
+    if (!condition) {
+      throw new errors.InvalidState(message);
+    }
+  },
+  checkArgument: function (condition, argumentName, message, docsPath) {
+    if (!condition) {
+      throw new errors.InvalidArgument(argumentName, message, docsPath);
+    }
+  },
+  checkArgumentType: function (argument, type, argumentName) {
+    argumentName = argumentName || '(unknown name)';
+    if (_.isString(type)) {
+      if (type === 'Buffer') {
+        if (!Buffer.isBuffer(argument)) {
+          throw new errors.InvalidArgumentType(argument, type, argumentName);
+        }
+      } else if (typeof argument !== type) {
+        throw new errors.InvalidArgumentType(argument, type, argumentName);
+      }
+    } else {
+      if (!(argument instanceof type)) {
+        throw new errors.InvalidArgumentType(argument, type.name, argumentName);
+      }
+    }
+  },
+};

package/fixup.cjs

@@ -0,0 +1,17 @@
+const glob = require('glob');
+const fs = require('fs');
+
+const updateRequires = (filePath) => {
+  let content = fs.readFileSync(filePath, 'utf8');
+  content = content.replace(/.cjs/g, ".js");
+  fs.writeFileSync(filePath, content, 'utf8');
+};
+
+async function main() {
+  const files = await glob.glob('./esm/**/*.js', { nodir: true });
+  files.forEach((file) => {
+    updateRequires(file);
+  });
+}
+
+main();

package/package.json

@@ -1,11 +1,23 @@
 {
   "name": "@opcat-labs/opcat",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "opcat base SDK",
-  "main": "./index.js",
-  "types": "./index.d.ts",
+  "main": "./cjs/index.cjs",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.cts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.cjs",
+      "import": "./esm/index.js",
+      "types": "./types/index.d.cts"
+    }
+  },
   "scripts": {
-    "lint": "standard --fix",
+    "gen:esm": "cjs2esm",
+    "postgen:esm": "npm run fixup",
+    "fixup": "node fixup.cjs",
+    "gen:types": "tsc",
     "test": "mocha"
   },
   "dependencies": {
@@ -18,6 +30,8 @@
     "unorm": "1.4.1"
   },
   "devDependencies": {
+    "cjs2esm": "^5.0.0",
+    "clone-deep": "^4.0.1",
     "parcel": "^2.15.2",
     "sinon": "^20.0.0"
   },

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

@@ -265,13 +265,7 @@ describe('Address', function () {
     it('should error because of incorrect type for pubkey transform', function () {
       (function () {
         return Address._transformPublicKey(Buffer.alloc(20));
-      }).should.throw('Address must be an instance of PublicKey.');
-    });
-
-    it('should error because of incorrect type for script transform', function () {
-      (function () {
-        return Address._transformScript(Buffer.alloc(20));
-      }).should.throw('Invalid Argument: script must be a Script instance');
+      }).should.throw('Pubkey supplied is not a buffer with 33 or 65 bytes.');
     });
 
     it('should error because of incorrect type for string transform', function () {
@@ -315,7 +309,7 @@ describe('Address', function () {
       var pubkey = new PublicKey(
         '0285e9737a74c30a873f74df05124f2aa6f53042c2fc0a130d6cbd7d16b944b004',
       );
-      var address = Address.fromPublicKey(pubkey, 'livenet');
+      var address = Address.fromPublicKey(pubkey.toBuffer(), 'livenet');
       address.toString().should.equal('19gH5uhqY6DKrtkU66PsZPUZdzTd11Y7ke');
     });
 
@@ -323,7 +317,7 @@ describe('Address', function () {
       var pubkey = new PublicKey(
         '0285e9737a74c30a873f74df05124f2aa6f53042c2fc0a130d6cbd7d16b944b004',
       );
-      var address = Address.fromPublicKey(pubkey);
+      var address = Address.fromPublicKey(pubkey.toBuffer());
       address.network.should.equal(Networks.defaultNetwork);
     });
 
@@ -332,9 +326,9 @@ describe('Address', function () {
         '0485e9737a74c30a873f74df05124f2aa6f53042c2fc0a130d6cbd7d16b944b00' +
           '4833fef26c8be4c4823754869ff4e46755b85d851077771c220e2610496a29d98',
       );
-      var a = Address.fromPublicKey(pubkey, 'livenet');
+      var a = Address.fromPublicKey(pubkey.toBuffer(), 'livenet');
       a.toString().should.equal('16JXnhxjJUhxfyx4y6H4sFcxrgt8kQ8ewX');
-      var b = new Address(pubkey, 'livenet', 'pubkeyhash');
+      var b = new Address(pubkey.toBuffer(), 'livenet', 'pubkeyhash');
       b.toString().should.equal('16JXnhxjJUhxfyx4y6H4sFcxrgt8kQ8ewX');
     });
 
@@ -358,30 +352,6 @@ describe('Address', function () {
       Networks.remove(network);
     });
 
-    describe('from a script', function () {
-      it('should fail to build address from a non p2sh,p2pkh script', function () {
-        var s = new Script('OP_CHECKMULTISIG');
-        (function () {
-          return new Address(s);
-        }).should.throw('needs to be p2pkh in, p2pkh out, p2sh in, or p2sh out');
-      });
-      it('should make this address from a p2pkh output script', function () {
-        var s = new Script(
-          'OP_DUP OP_HASH160 20 ' +
-            '0xc8e11b0eb0d2ad5362d894f048908341fa61b6e1 OP_EQUALVERIFY OP_CHECKSIG',
-        );
-        var a = Address.fromScript(s, 'livenet');
-        a.toString().should.equal('1KK9oz4bFH8c1t6LmighHaoSEGx3P3FEmc');
-        var b = new Address(s, 'livenet');
-        b.toString().should.equal('1KK9oz4bFH8c1t6LmighHaoSEGx3P3FEmc');
-      });
-
-      it('returns the same address if the script is a pay to public key hash out', function () {
-        var address = '16JXnhxjJUhxfyx4y6H4sFcxrgt8kQ8ewX';
-        var script = Script.buildPublicKeyHashOut(new Address(address));
-        Address(script, Networks.livenet).toString().should.equal(address);
-      });
-    });
 
     it('should derive from this known address string livenet', function () {
       var address = new Address(str);
@@ -475,34 +445,35 @@ describe('Address', function () {
     it('should derive from public key', function () {
       let privateKey = PrivateKey.fromRandom();
       let publicKey = PublicKey.fromPrivateKey(privateKey);
-      let address = Address.fromPublicKey(publicKey);
+      let address = Address.fromPublicKey(publicKey.toBuffer(), publicKey.network);
       address.toString()[0].should.equal('1');
     });
 
     it('should derive from public key testnet', function () {
       let privateKey = PrivateKey.fromRandom('testnet');
-      let publicKey = PublicKey.fromPrivateKey(privateKey);
-      let address = Address.fromPublicKey(publicKey, 'testnet');
-      (address.toString()[0] === 'm' || address.toString()[0] === 'n').should.equal(true);
+      let address = privateKey.toAddress()
+      let addresStr = address.toString();
+      (addresStr[0] === 'm' || addresStr[0] === 'n').should.equal(true);
     });
   });
 
   describe('#fromPrivateKey', function () {
     it('should derive from public key', function () {
       let privateKey = PrivateKey.fromRandom();
-      let address = Address.fromPrivateKey(privateKey);
+      let address = privateKey.toAddress()
       address.toString()[0].should.equal('1');
     });
 
     it('should derive from public key testnet', function () {
       let privateKey = PrivateKey.fromRandom('testnet');
-      let address = Address.fromPrivateKey(privateKey, 'testnet');
-      (address.toString()[0] === 'm' || address.toString()[0] === 'n').should.equal(true);
+      let address = privateKey.toAddress()
+      let addresStr = address.toString();
+      (addresStr[0] === 'm' || addresStr[0] === 'n').should.equal(true);
     });
 
     it('should derive from public key testnet', function () {
       let privateKey = PrivateKey.fromRandom('testnet');
-      let address = Address.fromPrivateKey(privateKey);
+      let address = privateKey.toAddress();
       (address.toString()[0] === 'm' || address.toString()[0] === 'n').should.equal(true);
     });
   });

package/test/block/{block.js → block.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var opcat = require('../..');
-var BN = require('../../lib/crypto/bn');
+var BN = opcat.crypto.BN
 var BufferReader = opcat.encoding.BufferReader;
 var BufferWriter = opcat.encoding.BufferWriter;
 var BlockHeader = opcat.BlockHeader;
@@ -11,11 +11,9 @@ var fs = require('fs');
 var should = chai.should();
 var Transaction = opcat.Transaction;
 
-// https://test-insight.bitpay.com/block/000000000b99b16390660d79fcc138d2ad0c89a0d044c4201a02bdf1f61ffa11
-var dataRawBlockBuffer = fs.readFileSync('test/data/blk86756-testnet.dat');
-var dataRawBlockBinary = fs.readFileSync('test/data/blk86756-testnet.dat', 'binary');
+
 var dataJson = fs.readFileSync('test/data/blk86756-testnet.json').toString();
-var data = require('../data/blk86756-testnet');
+var data = require('../data/blk86756-testnet.cjs');
 var dataBlocks = require('../data/bitcoind/blocks');
 var bockHex = fs.readFileSync('test/data/block.hex').toString();
 

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

@@ -1,7 +1,7 @@
 'use strict';
 
 var opcat = require('../..');
-var BN = require('../../lib/crypto/bn');
+var BN = opcat.crypto.BN;
 var BufferReader = opcat.encoding.BufferReader;
 var BufferWriter = opcat.encoding.BufferWriter;
 
@@ -13,7 +13,7 @@ var should = require('chai').should();
 var dataRawBlockBuffer = fs.readFileSync('test/data/blk86756-testnet.dat');
 var dataRawBlockBinary = fs.readFileSync('test/data/blk86756-testnet.dat', 'binary');
 var dataRawId = '000000000b99b16390660d79fcc138d2ad0c89a0d044c4201a02bdf1f61ffa11';
-var data = require('../data/blk86756-testnet');
+var data = require('../data/blk86756-testnet.cjs');
 
 describe('BlockHeader', function () {
   var version = data.version;

package/test/block/{merklebloack.js → merklebloack.cjs}

@@ -2,12 +2,12 @@
 
 var should = require('chai').should();
 
-var opcat = require('../../index.js');
+var opcat = require('../../');
 var MerkleBlock = opcat.MerkleBlock;
 var BufferReader = opcat.encoding.BufferReader;
 var BufferWriter = opcat.encoding.BufferWriter;
 var Transaction = opcat.Transaction;
-var data = require('../data/merkleblocks.js');
+var data = require('../data/merkleblocks.cjs');
 var transactionVector = require('../data/tx_creation');
 
 describe('MerkleBlock', function () {

package/test/crypto/{ecdsa.js → ecdsa.cjs}

@@ -1,14 +1,14 @@
 'use strict';
-
-var ECDSA = require('../../lib/crypto/ecdsa');
-var Hash = require('../../lib/crypto/hash');
-var Privkey = require('../../lib/privatekey');
-var Pubkey = require('../../lib/publickey');
-var Signature = require('../../lib/crypto/signature');
-var BN = require('../../lib/crypto/bn');
-var point = require('../../lib/crypto/point');
+var opcat = require('../../')
+var ECDSA = opcat.crypto.ECDSA;
+var Hash = opcat.crypto.Hash;
+var Privkey = opcat.PrivateKey;
+var Pubkey = opcat.PublicKey;
+var Signature = opcat.crypto.Signature;
+var BN = opcat.crypto.BN;
+var point = opcat.crypto.Point;
 var should = require('chai').should();
-var vectors = require('../data/ecdsa');
+var vectors = require('../data/ecdsa.json');
 
 describe('ECDSA', function () {
   it('instantiation', function () {

package/test/crypto/{hash.browser.js → hash.browser.cjs}

@@ -1,7 +1,8 @@
 'use strict';
 
 require('chai').should();
-var Hash = require('../../lib/crypto/hash.browser');
+var opcat = require('../../')
+var Hash = opcat.crypto.Hash;
 
 describe('Hash', function () {
   var buf = Buffer.from([0, 1, 2, 3, 253, 254, 255]);

package/test/crypto/{signature.js → signature.cjs}

@@ -1,12 +1,12 @@
 'use strict';
 
-var _ = require('../../lib/util/_');
 var should = require('chai').should();
 var opcat = require('../..');
+var _ = opcat.util._;
 var BN = opcat.crypto.BN;
 var Signature = opcat.crypto.Signature;
 var JSUtil = opcat.util.js;
-var Interpreter = opcat.Script.Interpreter;
+var Interpreter = opcat.Interpreter;
 
 var sigCanonical = require('../data/bitcoind/sig_canonical');
 var sigNonCanonical = require('../data/bitcoind/sig_noncanonical');