@opcat-labs/opcat 1.0.1 → 1.0.3

package/lib/crypto/hash.js

@@ -1,2 +0,0 @@
-if (process.browser) module.exports = require('./hash.browser');
-else module.exports = require('./hash.node');

package/lib/crypto/random.browser.js

@@ -1,28 +0,0 @@
-'use strict';
-
-function Random() {}
-
-/* secure random bytes that sometimes throws an error due to lack of entropy */
-Random.getRandomBuffer = function (size) {
-  if (!window.crypto && !window.msCrypto) {
-    throw new Error('window.crypto not available');
-  }
-  var crypto;
-
-  if (window.crypto && window.crypto.getRandomValues) {
-    crypto = window.crypto;
-  } else if (window.msCrypto && window.msCrypto.getRandomValues) {
-    // internet explorer
-    crypto = window.msCrypto;
-  } else {
-    throw new Error('window.crypto.getRandomValues not available');
-  }
-
-  var bbuf = new Uint8Array(size);
-  crypto.getRandomValues(bbuf);
-  var buf = Buffer.from(bbuf);
-
-  return buf;
-};
-
-module.exports = Random;

package/lib/crypto/random.js

@@ -1,2 +0,0 @@
-if (process.browser) module.exports = require('./random.browser');
-else module.exports = require('./random.node');

package/lib/crypto/random.node.js

@@ -1,11 +0,0 @@
-'use strict';
-
-function Random() {}
-
-/* secure random bytes that sometimes throws an error due to lack of entropy */
-Random.getRandomBuffer = function (size) {
-  var crypto = require('crypto');
-  return crypto.randomBytes(size);
-};
-
-module.exports = Random;

package/lib/encoding/base58check.js

@@ -1,121 +0,0 @@
-'use strict';
-
-var _ = require('../util/_');
-var Base58 = require('./base58');
-var sha256sha256 = require('../crypto/hash').sha256sha256;
-
-/**
- * A Base58check object can encode/decodd Base 58, which is used primarily for
- * string-formatted Bitcoin addresses and private keys. This is the same as
- * Base58, except that it includes a checksum to prevent accidental mistypings.
- *
- * @param {object} obj Can be a string or buffer.
- */
-var Base58Check = function Base58Check(obj) {
-  if (!(this instanceof Base58Check)) {
-    return new Base58Check(obj);
-  }
-  if (Buffer.isBuffer(obj)) {
-    var buf = obj;
-    this.fromBuffer(buf);
-  } else if (typeof obj === 'string') {
-    var str = obj;
-    this.fromString(str);
-  }
-};
-
-Base58Check.prototype.set = function (obj) {
-  this.buf = obj.buf || this.buf || undefined;
-  return this;
-};
-
-Base58Check.validChecksum = function validChecksum(data, checksum) {
-  if (_.isString(data)) {
-    data = Buffer.from(Base58.decode(data));
-  }
-  if (_.isString(checksum)) {
-    checksum = Buffer.from(Base58.decode(checksum));
-  }
-  if (!checksum) {
-    checksum = data.slice(-4);
-    data = data.slice(0, -4);
-  }
-  return Base58Check.checksum(data).toString('hex') === checksum.toString('hex');
-};
-
-Base58Check.decode = function (s) {
-  if (typeof s !== 'string') {
-    throw new Error('Input must be a string');
-  }
-
-  var buf = Buffer.from(Base58.decode(s));
-
-  if (buf.length < 4) {
-    throw new Error('Input string too short');
-  }
-
-  var data = buf.slice(0, -4);
-  var csum = buf.slice(-4);
-
-  var hash = sha256sha256(data);
-  var hash4 = hash.slice(0, 4);
-
-  if (csum.toString('hex') !== hash4.toString('hex')) {
-    throw new Error('Checksum mismatch');
-  }
-
-  return data;
-};
-
-Base58Check.checksum = function (buffer) {
-  return sha256sha256(buffer).slice(0, 4);
-};
-
-Base58Check.encode = function (buf) {
-  if (!Buffer.isBuffer(buf)) {
-    throw new Error('Input must be a buffer');
-  }
-  var checkedBuf = Buffer.alloc(buf.length + 4);
-  var hash = Base58Check.checksum(buf);
-  buf.copy(checkedBuf);
-  hash.copy(checkedBuf, buf.length);
-  return Base58.encode(checkedBuf);
-};
-
-Base58Check.prototype.fromBuffer = function (buf) {
-  this.buf = buf;
-  return this;
-};
-
-Base58Check.fromBuffer = function (buf) {
-  return new Base58Check().fromBuffer(buf);
-};
-
-Base58Check.fromHex = function (hex) {
-  return Base58Check.fromBuffer(Buffer.from(hex, 'hex'));
-};
-
-Base58Check.prototype.fromString = function (str) {
-  var buf = Base58Check.decode(str);
-  this.buf = buf;
-  return this;
-};
-
-Base58Check.fromString = function (str) {
-  var buf = Base58Check.decode(str);
-  return new Base58(buf);
-};
-
-Base58Check.prototype.toBuffer = function () {
-  return this.buf;
-};
-
-Base58Check.prototype.toHex = function () {
-  return this.toBuffer().toString('hex');
-};
-
-Base58Check.prototype.toString = function () {
-  return Base58Check.encode(this.buf);
-};
-
-module.exports = Base58Check;

package/lib/encoding/bufferreader.js

@@ -1,212 +0,0 @@
-'use strict';
-
-var _ = require('../util/_');
-var $ = require('../util/preconditions');
-var BN = require('../crypto/bn');
-
-var BufferReader = function BufferReader(buf) {
-  if (!(this instanceof BufferReader)) {
-    return new BufferReader(buf);
-  }
-  if (_.isUndefined(buf)) {
-    return;
-  }
-  if (Buffer.isBuffer(buf)) {
-    this.set({
-      buf: buf,
-    });
-  } else if (_.isString(buf)) {
-    var b = Buffer.from(buf, 'hex');
-    if (b.length * 2 !== buf.length) {
-      throw new TypeError('Invalid hex string');
-    }
-
-    this.set({
-      buf: b,
-    });
-  } else if (_.isObject(buf)) {
-    var obj = buf;
-    this.set(obj);
-  } else {
-    throw new TypeError('Unrecognized argument for BufferReader');
-  }
-};
-
-BufferReader.prototype.set = function (obj) {
-  this.buf = obj.buf || this.buf || undefined;
-  this.pos = obj.pos || this.pos || 0;
-  return this;
-};
-
-BufferReader.prototype.eof = function () {
-  return this.pos >= this.buf.length;
-};
-
-BufferReader.prototype.finished = BufferReader.prototype.eof;
-
-BufferReader.prototype.read = function (len) {
-  $.checkArgument(!_.isUndefined(len), 'Must specify a length');
-  var buf = this.buf.slice(this.pos, this.pos + len);
-  this.pos = this.pos + len;
-  return buf;
-};
-
-BufferReader.prototype.readAll = function () {
-  var buf = this.buf.slice(this.pos, this.buf.length);
-  this.pos = this.buf.length;
-  return buf;
-};
-
-BufferReader.prototype.readUInt8 = function () {
-  var val = this.buf.readUInt8(this.pos);
-  this.pos = this.pos + 1;
-  return val;
-};
-
-BufferReader.prototype.readUInt16BE = function () {
-  var val = this.buf.readUInt16BE(this.pos);
-  this.pos = this.pos + 2;
-  return val;
-};
-
-BufferReader.prototype.readUInt16LE = function () {
-  var val = this.buf.readUInt16LE(this.pos);
-  this.pos = this.pos + 2;
-  return val;
-};
-
-BufferReader.prototype.readUInt32BE = function () {
-  var val = this.buf.readUInt32BE(this.pos);
-  this.pos = this.pos + 4;
-  return val;
-};
-
-BufferReader.prototype.readUInt32LE = function () {
-  var val = this.buf.readUInt32LE(this.pos);
-  this.pos = this.pos + 4;
-  return val;
-};
-
-BufferReader.prototype.readInt32LE = function () {
-  var val = this.buf.readInt32LE(this.pos);
-  this.pos = this.pos + 4;
-  return val;
-};
-
-BufferReader.prototype.readUInt64BEBN = function () {
-  var buf = this.buf.slice(this.pos, this.pos + 8);
-  var bn = BN.fromBuffer(buf);
-  this.pos = this.pos + 8;
-  return bn;
-};
-
-BufferReader.prototype.readUInt64LEBN = function () {
-  var second = this.buf.readUInt32LE(this.pos);
-  var first = this.buf.readUInt32LE(this.pos + 4);
-  var combined = first * 0x100000000 + second;
-  // Instantiating an instance of BN with a number is faster than with an
-  // array or string. However, the maximum safe number for a double precision
-  // floating point is 2 ^ 52 - 1 (0x1fffffffffffff), thus we can safely use
-  // non-floating point numbers less than this amount (52 bits). And in the case
-  // that the number is larger, we can instatiate an instance of BN by passing
-  // an array from the buffer (slower) and specifying the endianness.
-  var bn;
-  if (combined <= 0x1fffffffffffff) {
-    bn = new BN(combined);
-  } else {
-    var data = Array.prototype.slice.call(this.buf, this.pos, this.pos + 8);
-    bn = new BN(data, 10, 'le');
-  }
-  this.pos = this.pos + 8;
-  return bn;
-};
-
-BufferReader.prototype.readVarintNum = function () {
-  var first = this.readUInt8();
-  switch (first) {
-    case 0xfd:
-      return this.readUInt16LE();
-    case 0xfe:
-      return this.readUInt32LE();
-    case 0xff:
-      var bn = this.readUInt64LEBN();
-      var n = bn.toNumber();
-      if (n <= Math.pow(2, 53)) {
-        return n;
-      } else {
-        throw new Error('number too large to retain precision - use readVarintBN');
-      }
-    // break // unreachable
-    default:
-      return first;
-  }
-};
-
-/**
- * reads a length prepended buffer
- */
-BufferReader.prototype.readVarLengthBuffer = function () {
-  var len = this.readVarintNum();
-  var buf = this.read(len);
-  $.checkState(
-    buf.length === len,
-    'Invalid length while reading varlength buffer. ' +
-      'Expected to read: ' +
-      len +
-      ' and read ' +
-      buf.length,
-  );
-  return buf;
-};
-
-BufferReader.prototype.readVarintBuf = function () {
-  var first = this.buf.readUInt8(this.pos);
-  switch (first) {
-    case 0xfd:
-      return this.read(1 + 2);
-    case 0xfe:
-      return this.read(1 + 4);
-    case 0xff:
-      return this.read(1 + 8);
-    default:
-      return this.read(1);
-  }
-};
-
-BufferReader.prototype.readVarintBN = function () {
-  var first = this.readUInt8();
-  switch (first) {
-    case 0xfd:
-      return new BN(this.readUInt16LE());
-    case 0xfe:
-      return new BN(this.readUInt32LE());
-    case 0xff:
-      return this.readUInt64LEBN();
-    default:
-      return new BN(first);
-  }
-};
-
-BufferReader.prototype.reverse = function () {
-  var buf = Buffer.alloc(this.buf.length);
-  for (var i = 0; i < buf.length; i++) {
-    buf[i] = this.buf[this.buf.length - 1 - i];
-  }
-  this.buf = buf;
-  return this;
-};
-
-BufferReader.prototype.readReverse = function (len) {
-  if (_.isUndefined(len)) {
-    len = this.buf.length;
-  }
-  var buf = this.buf.slice(this.pos, this.pos + len);
-  this.pos = this.pos + len;
-  return Buffer.from(buf).reverse();
-};
-
-BufferReader.prototype.remaining = function () {
-  return this.buf.length - this.pos;
-};
-
-module.exports = BufferReader;

package/lib/encoding/bufferwriter.js

@@ -1,140 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-
-const writeU8LE = require('../script/write-u8-le');
-const writeU16LE = require('../script/write-u16-le');
-const writeU32LE = require('../script/write-u32-le');
-const writeI32LE = require('../script/write-i32-le');
-const writeVarint = require('../script/write-varint');
-
-class BufferWriter {
-  constructor(obj) {
-    if (obj) {
-      this.set(obj);
-    } else {
-      this.buffers = [];
-      this.length = 0;
-    }
-  }
-
-  write(buffer) {
-    this.buffers.push(buffer);
-    this.length += buffer.length;
-    return this;
-  }
-
-  set(obj) {
-    this.buffers = obj.buffers || obj.bufs || this.buffers || [];
-    this.length = this.buffers.reduce(function (prev, buf) {
-      return prev + buf.length;
-    }, 0);
-    return this;
-  }
-
-  concat() {
-    return this.toBuffer();
-  }
-
-  toBuffer() {
-    if (this.buffers.length === 1) {
-      return Buffer.from(this.buffers[0]);
-    }
-
-    const whole = new Uint8Array(this.length);
-
-    let offset = 0;
-    this.buffers.forEach((part) => {
-      whole.set(part, offset);
-      offset += part.length;
-    });
-
-    return Buffer.from(whole);
-  }
-
-  writeReverse(buf) {
-    assert(Buffer.isBuffer(buf));
-    this.write(Buffer.from(buf).reverse());
-    return this;
-  }
-
-  writeUInt16LE(n) {
-    writeU16LE(this, n);
-    return this;
-  }
-
-  writeUInt16BE(n) {
-    var bw = new BufferWriter();
-    bw.writeUInt16LE(n);
-    this.writeReverse(bw.toBuffer());
-    return this;
-  }
-
-  writeUInt32LE(n) {
-    writeU32LE(this, n);
-    return this;
-  }
-
-  writeUInt32BE(n) {
-    var bw = new BufferWriter();
-    bw.writeUInt32LE(n);
-    this.writeReverse(bw.toBuffer());
-    return this;
-  }
-
-  writeUInt8(n) {
-    writeU8LE(this, n);
-    return this;
-  }
-
-  writeUInt64LEBN(bn) {
-    var buf = bn.toBuffer({ size: 8 });
-    this.writeReverse(buf);
-    return this;
-  }
-
-  writeUInt64BEBN(bn) {
-    var bw = new BufferWriter();
-    bw.writeUInt64LEBN(bn);
-    this.writeReverse(bw.toBuffer());
-    return this;
-  }
-
-  writeVarintNum(n) {
-    writeVarint(this, n);
-    return this;
-  }
-
-  writeInt32LE(n) {
-    writeI32LE(this, n);
-    return this;
-  }
-
-  static varintBufNum(n) {
-    var bw = new BufferWriter();
-    bw.writeVarintNum(n);
-    return bw.toBuffer();
-  }
-
-  writeVarintBN(bn) {
-    var n = bn.toNumber();
-    if (n < 253) {
-      writeU8LE(this, n);
-    } else if (n < 0x10000) {
-      writeU8LE(this, 253);
-      writeU16LE(this, n);
-    } else if (n < 0x100000000) {
-      writeU8LE(this, 254);
-      writeU32LE(this, n);
-    } else {
-      var bw = new BufferWriter();
-      bw.writeUInt8(255);
-      bw.writeUInt64LEBN(bn);
-      var buf = bw.toBuffer();
-      this.write(buf);
-    }
-    return this;
-  }
-}
-
-module.exports = BufferWriter;

package/lib/encoding/varint.js

@@ -1,75 +0,0 @@
-'use strict';
-
-var BufferWriter = require('./bufferwriter');
-var BufferReader = require('./bufferreader');
-var BN = require('../crypto/bn');
-
-var Varint = function Varint(buf) {
-  if (!(this instanceof Varint)) {
-    return new Varint(buf);
-  }
-  if (Buffer.isBuffer(buf)) {
-    this.buf = buf;
-  } else if (typeof buf === 'number') {
-    var num = buf;
-    this.fromNumber(num);
-  } else if (buf instanceof BN) {
-    var bn = buf;
-    this.fromBN(bn);
-  } else if (buf) {
-    var obj = buf;
-    this.set(obj);
-  }
-};
-
-Varint.prototype.set = function (obj) {
-  this.buf = obj.buf || this.buf;
-  return this;
-};
-
-Varint.prototype.fromString = function (str) {
-  this.set({
-    buf: Buffer.from(str, 'hex'),
-  });
-  return this;
-};
-
-Varint.prototype.toString = function () {
-  return this.buf.toString('hex');
-};
-
-Varint.prototype.fromBuffer = function (buf) {
-  this.buf = buf;
-  return this;
-};
-
-Varint.prototype.fromBufferReader = function (br) {
-  this.buf = br.readVarintBuf();
-  return this;
-};
-
-Varint.prototype.fromBN = function (bn) {
-  var bw = new BufferWriter();
-  this.buf = bw.writeVarintBN(bn).toBuffer();
-  return this;
-};
-
-Varint.prototype.fromNumber = function (num) {
-  var bw = new BufferWriter();
-  this.buf = bw.writeVarintNum(num).toBuffer();
-  return this;
-};
-
-Varint.prototype.toBuffer = function () {
-  return this.buf;
-};
-
-Varint.prototype.toBN = function () {
-  return BufferReader(this.buf).readVarintBN();
-};
-
-Varint.prototype.toNumber = function () {
-  return BufferReader(this.buf).readVarintNum();
-};
-
-module.exports = Varint;

package/lib/hash-cache.js

@@ -1,50 +0,0 @@
-/**
- * Hash Cache
- * ==========
- *
- * For use in sighash.
- */
-'use strict';
-
-class HashCache {
-  constructor(prevoutsHashBuf, sequenceHashBuf, outputsHashBuf) {
-    this.prevoutsHashBuf = prevoutsHashBuf;
-    this.sequenceHashBuf = sequenceHashBuf;
-    this.outputsHashBuf = outputsHashBuf;
-  }
-
-  static fromBuffer(buf) {
-    return HashCache.fromJSON(JSON.parse(buf.toString()));
-  }
-
-  toBuffer() {
-    return Buffer.from(JSON.stringify(this.toJSON()));
-  }
-
-  static fromJSON(json) {
-    return new HashCache(
-      json.prevoutsHashBuf ? Buffer.from(json.prevoutsHashBuf, 'hex') : undefined,
-      json.sequenceHashBuf ? Buffer.from(json.sequenceHashBuf, 'hex') : undefined,
-      json.outputsHashBuf ? Buffer.from(json.outputsHashBuf, 'hex') : undefined,
-    );
-  }
-
-  toJSON() {
-    return {
-      prevoutsHashBuf: this.prevoutsHashBuf ? this.prevoutsHashBuf.toString('hex') : undefined,
-      sequenceHashBuf: this.sequenceHashBuf ? this.sequenceHashBuf.toString('hex') : undefined,
-      outputsHashBuf: this.outputsHashBuf ? this.outputsHashBuf.toString('hex') : undefined,
-    };
-  }
-
-  toHex() {
-    return this.toBuffer().toString('hex');
-  }
-
-  static fromHex(hex) {
-    const buf = Buffer.from(hex, 'hex');
-    return HashCache.fromBuffer(buf);
-  }
-}
-
-module.exports = HashCache;

package/lib/mnemonic/pbkdf2.js

@@ -1,2 +0,0 @@
-if (process.browser) module.exports = require('./pbkdf2.browser');
-else module.exports = require('./pbkdf2.node');

package/lib/mnemonic/words/index.js

@@ -1,8 +0,0 @@
-module.exports = {
-  CHINESE: require('./chinese'),
-  ENGLISH: require('./english'),
-  FRENCH: require('./french'),
-  ITALIAN: require('./italian'),
-  JAPANESE: require('./japanese'),
-  SPANISH: require('./spanish'),
-};

package/lib/script/index.js

@@ -1,5 +0,0 @@
-module.exports = require('./script');
-
-module.exports.Interpreter = require('./interpreter');
-
-module.exports.Stack = require('./stack');

package/lib/transaction/index.js

@@ -1,7 +0,0 @@
-module.exports = require('./transaction');
-
-module.exports.Input = require('./input');
-module.exports.Output = require('./output');
-module.exports.UnspentOutput = require('./unspentoutput');
-module.exports.Signature = require('./signature');
-module.exports.Sighash = require('./sighash');

package/lib/transaction/input/index.js

@@ -1,5 +0,0 @@
-module.exports = require('./input.js');
-
-module.exports.PublicKey = require('./publickey.js');
-module.exports.PublicKeyHash = require('./publickeyhash.js');
-module.exports.MultiSig = require('./multisig.js');