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

package/dependencies/src/bip32-2.0.4/src/bip32.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = require("./crypto");
+const bs58check = require('../../bs58check-2.1.2/index');
+const ecc = require('../../tiny-secp256k1-1.1.3/js');
+const typeforce = require('../../typeforce-1.18.0/index');
+const wif = require('../../wif-2.0.6/index');
+const UINT256_TYPE = typeforce.BufferN(32);
+const NETWORK_TYPE = typeforce.compile({
+    wif: typeforce.UInt8,
+    bip32: {
+        public: typeforce.UInt32,
+        private: typeforce.UInt32,
+    },
+});
+const BITCOIN = {
+    wif: 0x80,
+    bip32: {
+        public: 0x0488b21e,
+        private: 0x0488ade4,
+    },
+};
+const HIGHEST_BIT = 0x80000000;
+const UINT31_MAX = Math.pow(2, 31) - 1;
+function BIP32Path(value) {
+    return (typeforce.String(value) && value.match(/^(m\/)?(\d+'?\/)*\d+'?$/) !== null);
+}
+function UInt31(value) {
+    return typeforce.UInt32(value) && value <= UINT31_MAX;
+}
+class BIP32 {
+    constructor(__D, __Q, chainCode, network, __DEPTH = 0, __INDEX = 0, __PARENT_FINGERPRINT = 0x00000000) {
+        this.__D = __D;
+        this.__Q = __Q;
+        this.chainCode = chainCode;
+        this.network = network;
+        this.__DEPTH = __DEPTH;
+        this.__INDEX = __INDEX;
+        this.__PARENT_FINGERPRINT = __PARENT_FINGERPRINT;
+        typeforce(NETWORK_TYPE, network);
+        this.lowR = false;
+    }
+    get depth() {
+        return this.__DEPTH;
+    }
+    get index() {
+        return this.__INDEX;
+    }
+    get parentFingerprint() {
+        return this.__PARENT_FINGERPRINT;
+    }
+    get publicKey() {
+        if (this.__Q === undefined)
+            this.__Q = ecc.pointFromScalar(this.__D, true);
+        return this.__Q;
+    }
+    get privateKey() {
+        return this.__D;
+    }
+    get identifier() {
+        return crypto.hash160(this.publicKey);
+    }
+    get fingerprint() {
+        return this.identifier.slice(0, 4);
+    }
+    // Private === not neutered
+    // Public === neutered
+    isNeutered() {
+        return this.__D === undefined;
+    }
+    neutered() {
+        return fromPublicKeyLocal(this.publicKey, this.chainCode, this.network, this.depth, this.index, this.parentFingerprint);
+    }
+    toBase58() {
+        const network = this.network;
+        const version = !this.isNeutered()
+            ? network.bip32.private
+            : network.bip32.public;
+        const buffer = Buffer.allocUnsafe(78);
+        // 4 bytes: version bytes
+        buffer.writeUInt32BE(version, 0);
+        // 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ....
+        buffer.writeUInt8(this.depth, 4);
+        // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
+        buffer.writeUInt32BE(this.parentFingerprint, 5);
+        // 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
+        // This is encoded in big endian. (0x00000000 if master key)
+        buffer.writeUInt32BE(this.index, 9);
+        // 32 bytes: the chain code
+        this.chainCode.copy(buffer, 13);
+        // 33 bytes: the public key or private key data
+        if (!this.isNeutered()) {
+            // 0x00 + k for private keys
+            buffer.writeUInt8(0, 45);
+            this.privateKey.copy(buffer, 46);
+            // 33 bytes: the public key
+        }
+        else {
+            // X9.62 encoding for public keys
+            this.publicKey.copy(buffer, 45);
+        }
+        return bs58check.encode(buffer);
+    }
+    toWIF() {
+        if (!this.privateKey)
+            throw new TypeError('Missing private key');
+        return wif.encode(this.network.wif, this.privateKey, true);
+    }
+    // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions
+    derive(index) {
+        typeforce(typeforce.UInt32, index);
+        const isHardened = index >= HIGHEST_BIT;
+        const data = Buffer.allocUnsafe(37);
+        // Hardened child
+        if (isHardened) {
+            if (this.isNeutered())
+                throw new TypeError('Missing private key for hardened child key');
+            // data = 0x00 || ser256(kpar) || ser32(index)
+            data[0] = 0x00;
+            this.privateKey.copy(data, 1);
+            data.writeUInt32BE(index, 33);
+            // Normal child
+        }
+        else {
+            // data = serP(point(kpar)) || ser32(index)
+            //      = serP(Kpar) || ser32(index)
+            this.publicKey.copy(data, 0);
+            data.writeUInt32BE(index, 33);
+        }
+        const I = crypto.hmacSHA512(this.chainCode, data);
+        const IL = I.slice(0, 32);
+        const IR = I.slice(32);
+        // if parse256(IL) >= n, proceed with the next value for i
+        if (!ecc.isPrivate(IL))
+            return this.derive(index + 1);
+        // Private parent key -> private child key
+        let hd;
+        if (!this.isNeutered()) {
+            // ki = parse256(IL) + kpar (mod n)
+            const ki = ecc.privateAdd(this.privateKey, IL);
+            // In case ki == 0, proceed with the next value for i
+            if (ki == null)
+                return this.derive(index + 1);
+            hd = fromPrivateKeyLocal(ki, IR, this.network, this.depth + 1, index, this.fingerprint.readUInt32BE(0));
+            // Public parent key -> public child key
+        }
+        else {
+            // Ki = point(parse256(IL)) + Kpar
+            //    = G*IL + Kpar
+            const Ki = ecc.pointAddScalar(this.publicKey, IL, true);
+            // In case Ki is the point at infinity, proceed with the next value for i
+            if (Ki === null)
+                return this.derive(index + 1);
+            hd = fromPublicKeyLocal(Ki, IR, this.network, this.depth + 1, index, this.fingerprint.readUInt32BE(0));
+        }
+        return hd;
+    }
+    deriveHardened(index) {
+        typeforce(UInt31, index);
+        // Only derives hardened private keys by default
+        return this.derive(index + HIGHEST_BIT);
+    }
+    derivePath(path) {
+        typeforce(BIP32Path, path);
+        let splitPath = path.split('/');
+        if (splitPath[0] === 'm') {
+            if (this.parentFingerprint)
+                throw new TypeError('Expected master, got child');
+            splitPath = splitPath.slice(1);
+        }
+        return splitPath.reduce((prevHd, indexStr) => {
+            let index;
+            if (indexStr.slice(-1) === `'`) {
+                index = parseInt(indexStr.slice(0, -1), 10);
+                return prevHd.deriveHardened(index);
+            }
+            else {
+                index = parseInt(indexStr, 10);
+                return prevHd.derive(index);
+            }
+        }, this);
+    }
+    sign(hash, lowR) {
+        if (!this.privateKey)
+            throw new Error('Missing private key');
+        if (lowR === undefined)
+            lowR = this.lowR;
+        if (lowR === false) {
+            return ecc.sign(hash, this.privateKey);
+        }
+        else {
+            let sig = ecc.sign(hash, this.privateKey);
+            const extraData = Buffer.alloc(32, 0);
+            let counter = 0;
+            // if first try is lowR, skip the loop
+            // for second try and on, add extra entropy counting up
+            while (sig[0] > 0x7f) {
+                counter++;
+                extraData.writeUIntLE(counter, 0, 6);
+                sig = ecc.signWithEntropy(hash, this.privateKey, extraData);
+            }
+            return sig;
+        }
+    }
+    verify(hash, signature) {
+        return ecc.verify(hash, this.publicKey, signature);
+    }
+}
+function fromBase58(inString, network) {
+    const buffer = bs58check.decode(inString);
+    if (buffer.length !== 78)
+        throw new TypeError('Invalid buffer length');
+    network = network || BITCOIN;
+    // 4 bytes: version bytes
+    const version = buffer.readUInt32BE(0);
+    if (version !== network.bip32.private && version !== network.bip32.public)
+        throw new TypeError('Invalid network version');
+    // 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ...
+    const depth = buffer[4];
+    // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
+    const parentFingerprint = buffer.readUInt32BE(5);
+    if (depth === 0) {
+        if (parentFingerprint !== 0x00000000)
+            throw new TypeError('Invalid parent fingerprint');
+    }
+    // 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
+    // This is encoded in MSB order. (0x00000000 if master key)
+    const index = buffer.readUInt32BE(9);
+    if (depth === 0 && index !== 0)
+        throw new TypeError('Invalid index');
+    // 32 bytes: the chain code
+    const chainCode = buffer.slice(13, 45);
+    let hd;
+    // 33 bytes: private key data (0x00 + k)
+    if (version === network.bip32.private) {
+        if (buffer.readUInt8(45) !== 0x00)
+            throw new TypeError('Invalid private key');
+        const k = buffer.slice(46, 78);
+        hd = fromPrivateKeyLocal(k, chainCode, network, depth, index, parentFingerprint);
+        // 33 bytes: public key data (0x02 + X or 0x03 + X)
+    }
+    else {
+        const X = buffer.slice(45, 78);
+        hd = fromPublicKeyLocal(X, chainCode, network, depth, index, parentFingerprint);
+    }
+    return hd;
+}
+exports.fromBase58 = fromBase58;
+function fromPrivateKey(privateKey, chainCode, network) {
+    return fromPrivateKeyLocal(privateKey, chainCode, network);
+}
+exports.fromPrivateKey = fromPrivateKey;
+function fromPrivateKeyLocal(privateKey, chainCode, network, depth, index, parentFingerprint) {
+    typeforce({
+        privateKey: UINT256_TYPE,
+        chainCode: UINT256_TYPE,
+    }, { privateKey, chainCode });
+    network = network || BITCOIN;
+    if (!ecc.isPrivate(privateKey))
+        throw new TypeError('Private key not in range [1, n)');
+    return new BIP32(privateKey, undefined, chainCode, network, depth, index, parentFingerprint);
+}
+function fromPublicKey(publicKey, chainCode, network) {
+    return fromPublicKeyLocal(publicKey, chainCode, network);
+}
+exports.fromPublicKey = fromPublicKey;
+function fromPublicKeyLocal(publicKey, chainCode, network, depth, index, parentFingerprint) {
+    typeforce({
+        publicKey: typeforce.BufferN(33),
+        chainCode: UINT256_TYPE,
+    }, { publicKey, chainCode });
+    network = network || BITCOIN;
+    // verify the X coordinate is a point on the curve
+    if (!ecc.isPoint(publicKey))
+        throw new TypeError('Point is not on the curve');
+    return new BIP32(undefined, publicKey, chainCode, network, depth, index, parentFingerprint);
+}
+function fromSeed(seed, network) {
+    typeforce(typeforce.Buffer, seed);
+    if (seed.length < 16)
+        throw new TypeError('Seed should be at least 128 bits');
+    if (seed.length > 64)
+        throw new TypeError('Seed should be at most 512 bits');
+    network = network || BITCOIN;
+    const I = crypto.hmacSHA512(Buffer.from('Bitcoin seed', 'utf8'), seed);
+    const IL = I.slice(0, 32);
+    const IR = I.slice(32);
+    return fromPrivateKey(IL, IR, network);
+}
+exports.fromSeed = fromSeed;

package/dependencies/src/bip32-2.0.4/src/crypto.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createHash = require('../../create-hash-1.2.0/browser');
+const createHmac = require('../../create-hmac-1.1.7/browser');
+function hash160(buffer) {
+    const sha256Hash = createHash('sha256')
+        .update(buffer)
+        .digest();
+    try {
+        return createHash('rmd160')
+            .update(sha256Hash)
+            .digest();
+    }
+    catch (err) {
+        return createHash('ripemd160')
+            .update(sha256Hash)
+            .digest();
+    }
+}
+exports.hash160 = hash160;
+function hmacSHA512(key, data) {
+    return createHmac('sha512', key)
+        .update(data)
+        .digest();
+}
+exports.hmacSHA512 = hmacSHA512;

package/dependencies/src/bip32-2.0.4/src/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var bip32_1 = require("./bip32");
+exports.fromSeed = bip32_1.fromSeed;
+exports.fromBase58 = bip32_1.fromBase58;
+exports.fromPublicKey = bip32_1.fromPublicKey;
+exports.fromPrivateKey = bip32_1.fromPrivateKey;

package/dependencies/src/bip32-path-0.4.2/index.js

@@ -0,0 +1,96 @@
+/*
+ * Bitcoin BIP32 path helpers
+ * (C) 2016 Alex Beregszaszi
+ */
+
+const HARDENED = 0x80000000
+
+var BIPPath = function (path) {
+  if (!Array.isArray(path)) {
+    throw new Error('Input must be an Array')
+  }
+  if (path.length === 0) {
+    throw new Error('Path must contain at least one level')
+  }
+  for (var i = 0; i < path.length; i++) {
+    if (typeof path[i] !== 'number') {
+      throw new Error('Path element is not a number')
+    }
+  }
+  this.path = path
+}
+
+BIPPath.validatePathArray = function (path) {
+  try {
+    BIPPath.fromPathArray(path)
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+BIPPath.validateString = function (text, reqRoot) {
+  try {
+    BIPPath.fromString(text, reqRoot)
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+BIPPath.fromPathArray = function (path) {
+  return new BIPPath(path)
+}
+
+BIPPath.fromString = function (text, reqRoot) {
+  // skip the root
+  if (/^m\//i.test(text)) {
+    text = text.slice(2)
+  } else if (reqRoot) {
+    throw new Error('Root element is required')
+  }
+
+  var path = text.split('/')
+  var ret = new Array(path.length)
+  for (var i = 0; i < path.length; i++) {
+    var tmp = /(\d+)([hH\']?)/.exec(path[i])
+    if (tmp === null) {
+      throw new Error('Invalid input')
+    }
+    ret[i] = parseInt(tmp[1], 10)
+
+    if (ret[i] >= HARDENED) {
+      throw new Error('Invalid child index')
+    }
+
+    if (tmp[2] === 'h' || tmp[2] === 'H' || tmp[2] === '\'') {
+      ret[i] += HARDENED
+    } else if (tmp[2].length != 0) {
+      throw new Error('Invalid modifier')
+    }
+  }
+  return new BIPPath(ret)
+}
+
+BIPPath.prototype.toPathArray = function () {
+  return this.path
+}
+
+BIPPath.prototype.toString = function (noRoot, oldStyle) {
+  var ret = new Array(this.path.length)
+  for (var i = 0; i < this.path.length; i++) {
+    var tmp = this.path[i]
+    if (tmp & HARDENED) {
+      ret[i] = (tmp & ~HARDENED) + (oldStyle ? 'h' : '\'')
+    } else {
+      ret[i] = tmp
+    }
+  }
+  return (noRoot ? '' : 'm/') + ret.join('/')
+}
+
+BIPPath.prototype.inspect = function () {
+  return 'BIPPath <' + this.toString() + '>'
+}
+
+module.exports = BIPPath

package/dependencies/src/bip39-2.5.0/index.js

@@ -0,0 +1,153 @@
+var Buffer = require('../safe-buffer-5.2.0/index').Buffer
+var createHash = require('../create-hash-1.2.0/browser')
+var pbkdf2 = require('../pbkdf2-3.0.17/index').pbkdf2Sync
+var randomBytes = require('../randombytes-2.1.0/browser')
+
+// use unorm until String.prototype.normalize gets better browser support
+var unorm = require('../unorm-1.6.0/lib/unorm')
+
+var CHINESE_SIMPLIFIED_WORDLIST = require('./wordlists/chinese_simplified.json')
+var CHINESE_TRADITIONAL_WORDLIST = require('./wordlists/chinese_traditional.json')
+var ENGLISH_WORDLIST = require('./wordlists/english.json')
+var FRENCH_WORDLIST = require('./wordlists/french.json')
+var ITALIAN_WORDLIST = require('./wordlists/italian.json')
+var JAPANESE_WORDLIST = require('./wordlists/japanese.json')
+var KOREAN_WORDLIST = require('./wordlists/korean.json')
+var SPANISH_WORDLIST = require('./wordlists/spanish.json')
+var DEFAULT_WORDLIST = ENGLISH_WORDLIST
+
+var INVALID_MNEMONIC = 'Invalid mnemonic'
+var INVALID_ENTROPY = 'Invalid entropy'
+var INVALID_CHECKSUM = 'Invalid mnemonic checksum'
+
+function lpad (str, padString, length) {
+  while (str.length < length) str = padString + str
+  return str
+}
+
+function binaryToByte (bin) {
+  return parseInt(bin, 2)
+}
+
+function bytesToBinary (bytes) {
+  return bytes.map(function (x) {
+    return lpad(x.toString(2), '0', 8)
+  }).join('')
+}
+
+function deriveChecksumBits (entropyBuffer) {
+  var ENT = entropyBuffer.length * 8
+  var CS = ENT / 32
+  var hash = createHash('sha256').update(entropyBuffer).digest()
+
+  return bytesToBinary([].slice.call(hash)).slice(0, CS)
+}
+
+function salt (password) {
+  return 'mnemonic' + (password || '')
+}
+
+function mnemonicToSeed (mnemonic, password) {
+  var mnemonicBuffer = Buffer.from(unorm.nfkd(mnemonic), 'utf8')
+  var saltBuffer = Buffer.from(salt(unorm.nfkd(password)), 'utf8')
+
+  return pbkdf2(mnemonicBuffer, saltBuffer, 2048, 64, 'sha512')
+}
+
+function mnemonicToSeedHex (mnemonic, password) {
+  return mnemonicToSeed(mnemonic, password).toString('hex')
+}
+
+function mnemonicToEntropy (mnemonic, wordlist) {
+  wordlist = wordlist || DEFAULT_WORDLIST
+
+  var words = unorm.nfkd(mnemonic).split(' ')
+  if (words.length % 3 !== 0) throw new Error(INVALID_MNEMONIC)
+
+  // convert word indices to 11 bit binary strings
+  var bits = words.map(function (word) {
+    var index = wordlist.indexOf(word)
+    if (index === -1) throw new Error(INVALID_MNEMONIC)
+
+    return lpad(index.toString(2), '0', 11)
+  }).join('')
+
+  // split the binary string into ENT/CS
+  var dividerIndex = Math.floor(bits.length / 33) * 32
+  var entropyBits = bits.slice(0, dividerIndex)
+  var checksumBits = bits.slice(dividerIndex)
+
+  // calculate the checksum and compare
+  var entropyBytes = entropyBits.match(/(.{1,8})/g).map(binaryToByte)
+  if (entropyBytes.length < 16) throw new Error(INVALID_ENTROPY)
+  if (entropyBytes.length > 32) throw new Error(INVALID_ENTROPY)
+  if (entropyBytes.length % 4 !== 0) throw new Error(INVALID_ENTROPY)
+
+  var entropy = Buffer.from(entropyBytes)
+  var newChecksum = deriveChecksumBits(entropy)
+  if (newChecksum !== checksumBits) throw new Error(INVALID_CHECKSUM)
+
+  return entropy.toString('hex')
+}
+
+function entropyToMnemonic (entropy, wordlist) {
+  if (!Buffer.isBuffer(entropy)) entropy = Buffer.from(entropy, 'hex')
+  wordlist = wordlist || DEFAULT_WORDLIST
+
+  // 128 <= ENT <= 256
+  if (entropy.length < 16) throw new TypeError(INVALID_ENTROPY)
+  if (entropy.length > 32) throw new TypeError(INVALID_ENTROPY)
+  if (entropy.length % 4 !== 0) throw new TypeError(INVALID_ENTROPY)
+
+  var entropyBits = bytesToBinary([].slice.call(entropy))
+  var checksumBits = deriveChecksumBits(entropy)
+
+  var bits = entropyBits + checksumBits
+  var chunks = bits.match(/(.{1,11})/g)
+  var words = chunks.map(function (binary) {
+    var index = binaryToByte(binary)
+    return wordlist[index]
+  })
+
+  return wordlist === JAPANESE_WORDLIST ? words.join('\u3000') : words.join(' ')
+}
+
+function generateMnemonic (strength, rng, wordlist) {
+  strength = strength || 128
+  if (strength % 32 !== 0) throw new TypeError(INVALID_ENTROPY)
+  rng = rng || randomBytes
+
+  return entropyToMnemonic(rng(strength / 8), wordlist)
+}
+
+function validateMnemonic (mnemonic, wordlist) {
+  try {
+    mnemonicToEntropy(mnemonic, wordlist)
+  } catch (e) {
+    return false
+  }
+
+  return true
+}
+
+module.exports = {
+  mnemonicToSeed: mnemonicToSeed,
+  mnemonicToSeedHex: mnemonicToSeedHex,
+  mnemonicToEntropy: mnemonicToEntropy,
+  entropyToMnemonic: entropyToMnemonic,
+  generateMnemonic: generateMnemonic,
+  validateMnemonic: validateMnemonic,
+  wordlists: {
+    EN: ENGLISH_WORDLIST,
+    JA: JAPANESE_WORDLIST,
+
+    chinese_simplified: CHINESE_SIMPLIFIED_WORDLIST,
+    chinese_traditional: CHINESE_TRADITIONAL_WORDLIST,
+    english: ENGLISH_WORDLIST,
+    french: FRENCH_WORDLIST,
+    italian: ITALIAN_WORDLIST,
+    japanese: JAPANESE_WORDLIST,
+    korean: KOREAN_WORDLIST,
+    spanish: SPANISH_WORDLIST
+  }
+}