@airgap/coinlib-core 0.13.11-beta.1 → 0.13.11-beta.2

package/dependencies/src/groestlcoinjs-message-2.1.0/index.js

@@ -0,0 +1,245 @@
+const bs58grscheck = require('../bs58grscheck-2.1.2/index')
+const bech32 = require('../bech32-1.1.3/index')
+const bufferEquals = require('../buffer-equals-1.0.4/index')
+const createHash = require('../create-hash-1.2.0/browser')
+const secp256k1 = require('../secp256k1-3.7.1/elliptic')
+const varuint = require('../varuint-bitcoin-1.1.2/index')
+
+const SEGWIT_TYPES = {
+  P2WPKH: 'p2wpkh',
+  P2SH_P2WPKH: 'p2sh(p2wpkh)'
+}
+
+function sha256 (b) {
+  return createHash('sha256')
+    .update(b)
+    .digest()
+}
+function hash160 (buffer) {
+  return createHash('ripemd160')
+    .update(sha256(buffer))
+    .digest()
+}
+
+function encodeSignature (signature, recovery, compressed, segwitType) {
+  if (segwitType !== undefined) {
+    recovery += 8
+    if (segwitType === SEGWIT_TYPES.P2WPKH) recovery += 4
+  } else {
+    if (compressed) recovery += 4
+  }
+  return Buffer.concat([Buffer.alloc(1, recovery + 27), signature])
+}
+
+/**
+  Electrum signs segwit messages as if they were compressed
+*/
+
+function encodeSignatureElectrum (signature, recovery, compressed, segwitType) {
+  if (segwitType !== undefined) {
+    recovery += 4
+  } else {
+    if (compressed) recovery += 4
+  }
+  return Buffer.concat([Buffer.alloc(1, recovery + 27), signature])
+}
+
+function decodeSignature (buffer) {
+  if (buffer.length !== 65) throw new Error('Invalid signature length')
+
+  const flagByte = buffer.readUInt8(0) - 27
+  if (flagByte > 15 || flagByte < 0) {
+    throw new Error('Invalid signature parameter')
+  }
+
+  return {
+    compressed: !!(flagByte & 12),
+    segwitType: !(flagByte & 8)
+      ? null
+      : !(flagByte & 4)
+        ? SEGWIT_TYPES.P2SH_P2WPKH
+        : SEGWIT_TYPES.P2WPKH,
+    recovery: flagByte & 3,
+    signature: buffer.slice(1)
+  }
+}
+
+function magicHash (message, messagePrefix) {
+  messagePrefix = messagePrefix || '\u001CGroestlCoin Signed Message:\n'
+  if (!Buffer.isBuffer(messagePrefix)) {
+    messagePrefix = Buffer.from(messagePrefix, 'utf8')
+  }
+
+  const messageVISize = varuint.encodingLength(message.length)
+  const buffer = Buffer.allocUnsafe(
+    messagePrefix.length + messageVISize + message.length
+  )
+  messagePrefix.copy(buffer, 0)
+  varuint.encode(message.length, buffer, messagePrefix.length)
+  buffer.write(message, messagePrefix.length + messageVISize)
+  return sha256(buffer)
+}
+
+function sign (
+  message,
+  privateKey,
+  compressed,
+  messagePrefix,
+  sigOptions
+) {
+  if (typeof messagePrefix === 'object' && sigOptions === undefined) {
+    sigOptions = messagePrefix
+    messagePrefix = undefined
+  }
+  let { segwitType, extraEntropy } = sigOptions || {}
+  if (
+    segwitType &&
+    (typeof segwitType === 'string' || segwitType instanceof String)
+  ) {
+    segwitType = segwitType.toLowerCase()
+  }
+  if (
+    segwitType &&
+    segwitType !== SEGWIT_TYPES.P2SH_P2WPKH &&
+    segwitType !== SEGWIT_TYPES.P2WPKH
+  ) {
+    throw new Error(
+      'Unrecognized segwitType: use "' +
+        SEGWIT_TYPES.P2SH_P2WPKH +
+        '" or "' +
+        SEGWIT_TYPES.P2WPKH +
+        '"'
+    )
+  }
+  const hash = magicHash(message, messagePrefix)
+  const sigObj = secp256k1.sign(hash, privateKey, { data: extraEntropy })
+  return encodeSignature(
+    sigObj.signature,
+    sigObj.recovery,
+    compressed,
+    segwitType
+  )
+}
+
+function signElectrum (
+  message,
+  privateKey,
+  compressed,
+  messagePrefix,
+  sigOptions
+) {
+  if (typeof messagePrefix === 'object' && sigOptions === undefined) {
+    sigOptions = messagePrefix
+    messagePrefix = undefined
+  }
+  let { segwitType, extraEntropy } = sigOptions || {}
+  if (
+    segwitType &&
+    (typeof segwitType === 'string' || segwitType instanceof String)
+  ) {
+    segwitType = segwitType.toLowerCase()
+  }
+  if (
+    segwitType &&
+    segwitType !== SEGWIT_TYPES.P2SH_P2WPKH &&
+    segwitType !== SEGWIT_TYPES.P2WPKH
+  ) {
+    throw new Error(
+      'Unrecognized segwitType: use "' +
+        SEGWIT_TYPES.P2SH_P2WPKH +
+        '" or "' +
+        SEGWIT_TYPES.P2WPKH +
+        '"'
+    )
+  }
+  const hash = magicHash(message, messagePrefix)
+  const sigObj = secp256k1.sign(hash, privateKey, { data: extraEntropy })
+  return encodeSignatureElectrum(
+    sigObj.signature,
+    sigObj.recovery,
+    compressed,
+    segwitType
+  )
+}
+
+function verify (message, address, signature, messagePrefix) {
+  if (!Buffer.isBuffer(signature)) signature = Buffer.from(signature, 'base64')
+
+  const parsed = decodeSignature(signature)
+  const hash = magicHash(message, messagePrefix)
+  const publicKey = secp256k1.recover(
+    hash,
+    parsed.signature,
+    parsed.recovery,
+    parsed.compressed
+  )
+  const publicKeyHash = hash160(publicKey)
+  let actual, expected
+
+  if (parsed.segwitType) {
+    if (parsed.segwitType === SEGWIT_TYPES.P2SH_P2WPKH) {
+      const redeemScript = Buffer.concat([
+        Buffer.from('0014', 'hex'),
+        publicKeyHash
+      ])
+      const redeemScriptHash = hash160(redeemScript)
+      actual = redeemScriptHash
+      expected = bs58grscheck.decode(address).slice(1)
+    } else if (parsed.segwitType === SEGWIT_TYPES.P2WPKH) {
+      const result = bech32.decode(address)
+      const data = bech32.fromWords(result.words.slice(1))
+      actual = publicKeyHash
+      expected = Buffer.from(data)
+    }
+  } else {
+    actual = publicKeyHash
+    expected = bs58grscheck.decode(address).slice(1)
+  }
+
+  return bufferEquals(actual, expected)
+}
+
+function verifyElectrum (message, address, signature, messagePrefix) {
+  if (!Buffer.isBuffer(signature)) signature = Buffer.from(signature, 'base64')
+
+  const parsed = decodeSignature(signature)
+  const hash = magicHash(message, messagePrefix)
+  const publicKey = secp256k1.recover(
+    hash,
+    parsed.signature,
+    parsed.recovery,
+    parsed.compressed
+  )
+  const publicKeyHash = hash160(publicKey)
+  let actual, expected
+
+  try {
+    const expectedHash160 = bs58grscheck.decode(address).slice(1)
+    // first check if this hash is the same as the publicKeyHash
+    // validate if it is P2PKH (starts with F)
+    if (bufferEquals(publicKeyHash, expectedHash160)) {
+      return true
+    }
+    // check if it is a segwit P2SH_P2WPKH address (starts with 3)
+    const redeemScript = Buffer.concat([
+      Buffer.from('0014', 'hex'),
+      publicKeyHash
+    ])
+    const redeemScriptHash = Buffer.from(hash160(redeemScript))
+    return bufferEquals(redeemScriptHash, expectedHash160)
+  } catch (e) {
+    const result = bech32.decode(address)
+    const data = bech32.fromWords(result.words.slice(1))
+    actual = publicKeyHash
+    expected = Buffer.from(data)
+    return bufferEquals(actual, expected)
+  }
+}
+
+module.exports = {
+  magicHash: magicHash,
+  sign: sign,
+  verify: verify,
+  signElectrum: signElectrum,
+  verifyElectrum: verifyElectrum
+}

package/dependencies/src/hash-base-3.0.4/index.js

@@ -0,0 +1,95 @@
+'use strict'
+var Buffer = require('../safe-buffer-5.2.0/index').Buffer
+var Transform = require('stream').Transform
+var inherits = require('../inherits-2.0.4/inherits')
+
+function throwIfNotStringOrBuffer (val, prefix) {
+  if (!Buffer.isBuffer(val) && typeof val !== 'string') {
+    throw new TypeError(prefix + ' must be a string or a buffer')
+  }
+}
+
+function HashBase (blockSize) {
+  Transform.call(this)
+
+  this._block = Buffer.allocUnsafe(blockSize)
+  this._blockSize = blockSize
+  this._blockOffset = 0
+  this._length = [0, 0, 0, 0]
+
+  this._finalized = false
+}
+
+inherits(HashBase, Transform)
+
+HashBase.prototype._transform = function (chunk, encoding, callback) {
+  var error = null
+  try {
+    this.update(chunk, encoding)
+  } catch (err) {
+    error = err
+  }
+
+  callback(error)
+}
+
+HashBase.prototype._flush = function (callback) {
+  var error = null
+  try {
+    this.push(this.digest())
+  } catch (err) {
+    error = err
+  }
+
+  callback(error)
+}
+
+HashBase.prototype.update = function (data, encoding) {
+  throwIfNotStringOrBuffer(data, 'Data')
+  if (this._finalized) throw new Error('Digest already called')
+  if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)
+
+  // consume data
+  var block = this._block
+  var offset = 0
+  while (this._blockOffset + data.length - offset >= this._blockSize) {
+    for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]
+    this._update()
+    this._blockOffset = 0
+  }
+  while (offset < data.length) block[this._blockOffset++] = data[offset++]
+
+  // update length
+  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
+    this._length[j] += carry
+    carry = (this._length[j] / 0x0100000000) | 0
+    if (carry > 0) this._length[j] -= 0x0100000000 * carry
+  }
+
+  return this
+}
+
+HashBase.prototype._update = function () {
+  throw new Error('_update is not implemented')
+}
+
+HashBase.prototype.digest = function (encoding) {
+  if (this._finalized) throw new Error('Digest already called')
+  this._finalized = true
+
+  var digest = this._digest()
+  if (encoding !== undefined) digest = digest.toString(encoding)
+
+  // reset state
+  this._block.fill(0)
+  this._blockOffset = 0
+  for (var i = 0; i < 4; ++i) this._length[i] = 0
+
+  return digest
+}
+
+HashBase.prototype._digest = function () {
+  throw new Error('_digest is not implemented')
+}
+
+module.exports = HashBase

package/dependencies/src/hash.js-1.1.7/lib/hash/common.js

@@ -0,0 +1,92 @@
+'use strict';
+
+var utils = require('./utils');
+var assert = require('../../../minimalistic-assert-1.0.1/index');
+
+function BlockHash() {
+  this.pending = null;
+  this.pendingTotal = 0;
+  this.blockSize = this.constructor.blockSize;
+  this.outSize = this.constructor.outSize;
+  this.hmacStrength = this.constructor.hmacStrength;
+  this.padLength = this.constructor.padLength / 8;
+  this.endian = 'big';
+
+  this._delta8 = this.blockSize / 8;
+  this._delta32 = this.blockSize / 32;
+}
+exports.BlockHash = BlockHash;
+
+BlockHash.prototype.update = function update(msg, enc) {
+  // Convert message to array, pad it, and join into 32bit blocks
+  msg = utils.toArray(msg, enc);
+  if (!this.pending)
+    this.pending = msg;
+  else
+    this.pending = this.pending.concat(msg);
+  this.pendingTotal += msg.length;
+
+  // Enough data, try updating
+  if (this.pending.length >= this._delta8) {
+    msg = this.pending;
+
+    // Process pending data in blocks
+    var r = msg.length % this._delta8;
+    this.pending = msg.slice(msg.length - r, msg.length);
+    if (this.pending.length === 0)
+      this.pending = null;
+
+    msg = utils.join32(msg, 0, msg.length - r, this.endian);
+    for (var i = 0; i < msg.length; i += this._delta32)
+      this._update(msg, i, i + this._delta32);
+  }
+
+  return this;
+};
+
+BlockHash.prototype.digest = function digest(enc) {
+  this.update(this._pad());
+  assert(this.pending === null);
+
+  return this._digest(enc);
+};
+
+BlockHash.prototype._pad = function pad() {
+  var len = this.pendingTotal;
+  var bytes = this._delta8;
+  var k = bytes - ((len + this.padLength) % bytes);
+  var res = new Array(k + this.padLength);
+  res[0] = 0x80;
+  for (var i = 1; i < k; i++)
+    res[i] = 0;
+
+  // Append length
+  len <<= 3;
+  if (this.endian === 'big') {
+    for (var t = 8; t < this.padLength; t++)
+      res[i++] = 0;
+
+    res[i++] = 0;
+    res[i++] = 0;
+    res[i++] = 0;
+    res[i++] = 0;
+    res[i++] = (len >>> 24) & 0xff;
+    res[i++] = (len >>> 16) & 0xff;
+    res[i++] = (len >>> 8) & 0xff;
+    res[i++] = len & 0xff;
+  } else {
+    res[i++] = len & 0xff;
+    res[i++] = (len >>> 8) & 0xff;
+    res[i++] = (len >>> 16) & 0xff;
+    res[i++] = (len >>> 24) & 0xff;
+    res[i++] = 0;
+    res[i++] = 0;
+    res[i++] = 0;
+    res[i++] = 0;
+
+    for (t = 8; t < this.padLength; t++)
+      res[i++] = 0;
+  }
+
+  return res;
+};

package/dependencies/src/hash.js-1.1.7/lib/hash/hmac.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var utils = require('./utils');
+var assert = require('../../../minimalistic-assert-1.0.1/index');
+
+function Hmac(hash, key, enc) {
+  if (!(this instanceof Hmac))
+    return new Hmac(hash, key, enc);
+  this.Hash = hash;
+  this.blockSize = hash.blockSize / 8;
+  this.outSize = hash.outSize / 8;
+  this.inner = null;
+  this.outer = null;
+
+  this._init(utils.toArray(key, enc));
+}
+module.exports = Hmac;
+
+Hmac.prototype._init = function init(key) {
+  // Shorten key, if needed
+  if (key.length > this.blockSize)
+    key = new this.Hash().update(key).digest();
+  assert(key.length <= this.blockSize);
+
+  // Add padding to key
+  for (var i = key.length; i < this.blockSize; i++)
+    key.push(0);
+
+  for (i = 0; i < key.length; i++)
+    key[i] ^= 0x36;
+  this.inner = new this.Hash().update(key);
+
+  // 0x36 ^ 0x5c = 0x6a
+  for (i = 0; i < key.length; i++)
+    key[i] ^= 0x6a;
+  this.outer = new this.Hash().update(key);
+};
+
+Hmac.prototype.update = function update(msg, enc) {
+  this.inner.update(msg, enc);
+  return this;
+};
+
+Hmac.prototype.digest = function digest(enc) {
+  this.outer.update(this.inner.digest());
+  return this.outer.digest(enc);
+};

package/dependencies/src/hash.js-1.1.7/lib/hash/ripemd.js

@@ -0,0 +1,146 @@
+'use strict';
+
+var utils = require('./utils');
+var common = require('./common');
+
+var rotl32 = utils.rotl32;
+var sum32 = utils.sum32;
+var sum32_3 = utils.sum32_3;
+var sum32_4 = utils.sum32_4;
+var BlockHash = common.BlockHash;
+
+function RIPEMD160() {
+  if (!(this instanceof RIPEMD160))
+    return new RIPEMD160();
+
+  BlockHash.call(this);
+
+  this.h = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ];
+  this.endian = 'little';
+}
+utils.inherits(RIPEMD160, BlockHash);
+exports.ripemd160 = RIPEMD160;
+
+RIPEMD160.blockSize = 512;
+RIPEMD160.outSize = 160;
+RIPEMD160.hmacStrength = 192;
+RIPEMD160.padLength = 64;
+
+RIPEMD160.prototype._update = function update(msg, start) {
+  var A = this.h[0];
+  var B = this.h[1];
+  var C = this.h[2];
+  var D = this.h[3];
+  var E = this.h[4];
+  var Ah = A;
+  var Bh = B;
+  var Ch = C;
+  var Dh = D;
+  var Eh = E;
+  for (var j = 0; j < 80; j++) {
+    var T = sum32(
+      rotl32(
+        sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),
+        s[j]),
+      E);
+    A = E;
+    E = D;
+    D = rotl32(C, 10);
+    C = B;
+    B = T;
+    T = sum32(
+      rotl32(
+        sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),
+        sh[j]),
+      Eh);
+    Ah = Eh;
+    Eh = Dh;
+    Dh = rotl32(Ch, 10);
+    Ch = Bh;
+    Bh = T;
+  }
+  T = sum32_3(this.h[1], C, Dh);
+  this.h[1] = sum32_3(this.h[2], D, Eh);
+  this.h[2] = sum32_3(this.h[3], E, Ah);
+  this.h[3] = sum32_3(this.h[4], A, Bh);
+  this.h[4] = sum32_3(this.h[0], B, Ch);
+  this.h[0] = T;
+};
+
+RIPEMD160.prototype._digest = function digest(enc) {
+  if (enc === 'hex')
+    return utils.toHex32(this.h, 'little');
+  else
+    return utils.split32(this.h, 'little');
+};
+
+function f(j, x, y, z) {
+  if (j <= 15)
+    return x ^ y ^ z;
+  else if (j <= 31)
+    return (x & y) | ((~x) & z);
+  else if (j <= 47)
+    return (x | (~y)) ^ z;
+  else if (j <= 63)
+    return (x & z) | (y & (~z));
+  else
+    return x ^ (y | (~z));
+}
+
+function K(j) {
+  if (j <= 15)
+    return 0x00000000;
+  else if (j <= 31)
+    return 0x5a827999;
+  else if (j <= 47)
+    return 0x6ed9eba1;
+  else if (j <= 63)
+    return 0x8f1bbcdc;
+  else
+    return 0xa953fd4e;
+}
+
+function Kh(j) {
+  if (j <= 15)
+    return 0x50a28be6;
+  else if (j <= 31)
+    return 0x5c4dd124;
+  else if (j <= 47)
+    return 0x6d703ef3;
+  else if (j <= 63)
+    return 0x7a6d76e9;
+  else
+    return 0x00000000;
+}
+
+var r = [
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
+  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
+  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
+];
+
+var rh = [
+  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
+  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
+  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
+  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
+  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
+];
+
+var s = [
+  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
+  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
+  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
+  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
+  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
+];
+
+var sh = [
+  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
+  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
+  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
+  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
+  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
+];

package/dependencies/src/hash.js-1.1.7/lib/hash/sha/1.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var utils = require('../utils');
+var common = require('../common');
+var shaCommon = require('./common');
+
+var rotl32 = utils.rotl32;
+var sum32 = utils.sum32;
+var sum32_5 = utils.sum32_5;
+var ft_1 = shaCommon.ft_1;
+var BlockHash = common.BlockHash;
+
+var sha1_K = [
+  0x5A827999, 0x6ED9EBA1,
+  0x8F1BBCDC, 0xCA62C1D6
+];
+
+function SHA1() {
+  if (!(this instanceof SHA1))
+    return new SHA1();
+
+  BlockHash.call(this);
+  this.h = [
+    0x67452301, 0xefcdab89, 0x98badcfe,
+    0x10325476, 0xc3d2e1f0 ];
+  this.W = new Array(80);
+}
+
+utils.inherits(SHA1, BlockHash);
+module.exports = SHA1;
+
+SHA1.blockSize = 512;
+SHA1.outSize = 160;
+SHA1.hmacStrength = 80;
+SHA1.padLength = 64;
+
+SHA1.prototype._update = function _update(msg, start) {
+  var W = this.W;
+
+  for (var i = 0; i < 16; i++)
+    W[i] = msg[start + i];
+
+  for(; i < W.length; i++)
+    W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
+
+  var a = this.h[0];
+  var b = this.h[1];
+  var c = this.h[2];
+  var d = this.h[3];
+  var e = this.h[4];
+
+  for (i = 0; i < W.length; i++) {
+    var s = ~~(i / 20);
+    var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
+    e = d;
+    d = c;
+    c = rotl32(b, 30);
+    b = a;
+    a = t;
+  }
+
+  this.h[0] = sum32(this.h[0], a);
+  this.h[1] = sum32(this.h[1], b);
+  this.h[2] = sum32(this.h[2], c);
+  this.h[3] = sum32(this.h[3], d);
+  this.h[4] = sum32(this.h[4], e);
+};
+
+SHA1.prototype._digest = function digest(enc) {
+  if (enc === 'hex')
+    return utils.toHex32(this.h, 'big');
+  else
+    return utils.split32(this.h, 'big');
+};