src/js/index.js

   1 (function() {
   2
   3     // mnemonics is populated as required by getLanguage
   4     var mnemonics = { "english": new Mnemonic("english") };
   5     var mnemonic = mnemonics["english"];
   6     var seed = null
   7     var bip32RootKey = null;
   8     var bip32ExtendedKey = null;
   9     var network = bitcoin.networks.bitcoin;
  10     var addressRowTemplate = $("#address-row-template");
  11
  12     var showIndex = true;
  13     var showAddress = true;
  14     var showPubKey = true;
  15     var showPrivKey = true;
  16     var showQr = true;
  17
  18     var entropyChangeTimeoutEvent = null;
  19     var phraseChangeTimeoutEvent = null;
  20     var rootKeyChangedTimeoutEvent = null;
  21
  22     var DOM = {};
  23     DOM.network = $(".network");
  24     DOM.phraseNetwork = $("#network-phrase");
  25     DOM.useEntropy = $(".use-entropy");
  26     DOM.entropyContainer = $(".entropy-container");
  27     DOM.entropy = $(".entropy");
  28     DOM.entropyFiltered = DOM.entropyContainer.find(".filtered");
  29     DOM.entropyType = DOM.entropyContainer.find(".type");
  30     DOM.entropyStrength = DOM.entropyContainer.find(".strength");
  31     DOM.entropyEventCount = DOM.entropyContainer.find(".event-count");
  32     DOM.entropyBits = DOM.entropyContainer.find(".bits");
  33     DOM.entropyBitsPerEvent = DOM.entropyContainer.find(".bits-per-event");
  34     DOM.entropyWordCount = DOM.entropyContainer.find(".word-count");
  35     DOM.entropyBinary = DOM.entropyContainer.find(".binary");
  36     DOM.entropyMnemonicLength = DOM.entropyContainer.find(".mnemonic-length");
  37     DOM.phrase = $(".phrase");
  38     DOM.passphrase = $(".passphrase");
  39     DOM.generateContainer = $(".generate-container");
  40     DOM.generate = $(".generate");
  41     DOM.seed = $(".seed");
  42     DOM.rootKey = $(".root-key");
  43     DOM.extendedPrivKey = $(".extended-priv-key");
  44     DOM.extendedPubKey = $(".extended-pub-key");
  45     DOM.bip32tab = $("#bip32-tab");
  46     DOM.bip44tab = $("#bip44-tab");
  47     DOM.bip32panel = $("#bip32");
  48     DOM.bip44panel = $("#bip44");
  49     DOM.bip32path = $("#bip32-path");
  50     DOM.bip44path = $("#bip44-path");
  51     DOM.bip44purpose = $("#bip44 .purpose");
  52     DOM.bip44coin = $("#bip44 .coin");
  53     DOM.bip44account = $("#bip44 .account");
  54     DOM.bip44change = $("#bip44 .change");
  55     DOM.generatedStrength = $(".generate-container .strength");
  56     DOM.hardenedAddresses = $(".hardened-addresses");
  57     DOM.addresses = $(".addresses");
  58     DOM.rowsToAdd = $(".rows-to-add");
  59     DOM.more = $(".more");
  60     DOM.feedback = $(".feedback");
  61     DOM.tab = $(".derivation-type a");
  62     DOM.indexToggle = $(".index-toggle");
  63     DOM.addressToggle = $(".address-toggle");
  64     DOM.publicKeyToggle = $(".public-key-toggle");
  65     DOM.privateKeyToggle = $(".private-key-toggle");
  66     DOM.languages = $(".languages a");
  67     DOM.qrContainer = $(".qr-container");
  68     DOM.qrImage = DOM.qrContainer.find(".qr-image");
  69     DOM.qrHint = DOM.qrContainer.find(".qr-hint");
  70     DOM.showQrEls = $("[data-show-qr]");
  71
  72     function init() {
  73         // Events
  74         DOM.network.on("change", networkChanged);
  75         DOM.useEntropy.on("change", setEntropyVisibility);
  76         DOM.entropy.on("input", delayedEntropyChanged);
  77         DOM.entropyMnemonicLength.on("change", entropyChanged);
  78         DOM.phrase.on("input", delayedPhraseChanged);
  79         DOM.passphrase.on("input", delayedPhraseChanged);
  80         DOM.generate.on("click", generateClicked);
  81         DOM.more.on("click", showMore);
  82         DOM.rootKey.on("input", delayedRootKeyChanged);
  83         DOM.bip32path.on("input", calcForDerivationPath);
  84         DOM.bip44purpose.on("input", calcForDerivationPath);
  85         DOM.bip44coin.on("input", calcForDerivationPath);
  86         DOM.bip44account.on("input", calcForDerivationPath);
  87         DOM.bip44change.on("input", calcForDerivationPath);
  88         DOM.tab.on("shown.bs.tab", calcForDerivationPath);
  89         DOM.hardenedAddresses.on("change", calcForDerivationPath);
  90         DOM.indexToggle.on("click", toggleIndexes);
  91         DOM.addressToggle.on("click", toggleAddresses);
  92         DOM.publicKeyToggle.on("click", togglePublicKeys);
  93         DOM.privateKeyToggle.on("click", togglePrivateKeys);
  94         DOM.languages.on("click", languageChanged);
  95         setQrEvents(DOM.showQrEls);
  96         disableForms();
  97         hidePending();
  98         hideValidationError();
  99         populateNetworkSelect();
 100     }
 101
 102     // Event handlers
 103
 104     function networkChanged(e) {
 105         var networkIndex = e.target.value;
 106         networks[networkIndex].onSelect();
 107         if (seed != null) {
 108             phraseChanged();
 109         }
 110         else {
 111             rootKeyChanged();
 112         }
 113     }
 114
 115     function setEntropyVisibility() {
 116         if (isUsingOwnEntropy()) {
 117             DOM.entropyContainer.removeClass("hidden");
 118             DOM.generateContainer.addClass("hidden");
 119             DOM.phrase.prop("readonly", true);
 120             DOM.entropy.focus();
 121             entropyChanged();
 122         }
 123         else {
 124             DOM.entropyContainer.addClass("hidden");
 125             DOM.generateContainer.removeClass("hidden");
 126             DOM.phrase.prop("readonly", false);
 127             hidePending();
 128         }
 129     }
 130
 131     function delayedPhraseChanged() {
 132         hideValidationError();
 133         showPending();
 134         if (phraseChangeTimeoutEvent != null) {
 135             clearTimeout(phraseChangeTimeoutEvent);
 136         }
 137         phraseChangeTimeoutEvent = setTimeout(phraseChanged, 400);
 138     }
 139
 140     function phraseChanged() {
 141         showPending();
 142         hideValidationError();
 143         setMnemonicLanguage();
 144         // Get the mnemonic phrase
 145         var phrase = DOM.phrase.val();
 146         var errorText = findPhraseErrors(phrase);
 147         if (errorText) {
 148             showValidationError(errorText);
 149             return;
 150         }
 151         // Calculate and display
 152         var passphrase = DOM.passphrase.val();
 153         calcBip32RootKeyFromSeed(phrase, passphrase);
 154         calcForDerivationPath();
 155         hidePending();
 156     }
 157
 158     function delayedEntropyChanged() {
 159         hideValidationError();
 160         showPending();
 161         if (entropyChangeTimeoutEvent != null) {
 162             clearTimeout(entropyChangeTimeoutEvent);
 163         }
 164         entropyChangeTimeoutEvent = setTimeout(entropyChanged, 400);
 165     }
 166
 167     function entropyChanged() {
 168         // If blank entropy, clear mnemonic, addresses, errors
 169         if (DOM.entropy.val().trim().length == 0) {
 170             clearDisplay();
 171             clearEntropyFeedback();
 172             DOM.phrase.val("");
 173             showValidationError("Blank entropy");
 174             return;
 175         }
 176         // Get the current phrase to detect changes
 177         var phrase = DOM.phrase.val();
 178         // Set the phrase from the entropy
 179         setMnemonicFromEntropy();
 180         // Recalc addresses if the phrase has changed
 181         var newPhrase = DOM.phrase.val();
 182         if (newPhrase != phrase) {
 183             if (newPhrase.length == 0) {
 184                 clearDisplay();
 185             }
 186             else {
 187                 phraseChanged();
 188             }
 189         }
 190         else {
 191             hidePending();
 192         }
 193     }
 194
 195     function delayedRootKeyChanged() {
 196         // Warn if there is an existing mnemonic or passphrase.
 197         if (DOM.phrase.val().length > 0 || DOM.passphrase.val().length > 0) {
 198             if (!confirm("This will clear existing mnemonic and passphrase")) {
 199                 DOM.rootKey.val(bip32RootKey);
 200                 return
 201             }
 202         }
 203         hideValidationError();
 204         showPending();
 205         // Clear existing mnemonic and passphrase
 206         DOM.phrase.val("");
 207         DOM.passphrase.val("");
 208         seed = null;
 209         if (rootKeyChangedTimeoutEvent != null) {
 210             clearTimeout(rootKeyChangedTimeoutEvent);
 211         }
 212         rootKeyChangedTimeoutEvent = setTimeout(rootKeyChanged, 400);
 213     }
 214
 215     function rootKeyChanged() {
 216         showPending();
 217         hideValidationError();
 218         // Validate the root key TODO
 219         var rootKeyBase58 = DOM.rootKey.val();
 220         var errorText = validateRootKey(rootKeyBase58);
 221         if (errorText) {
 222             showValidationError(errorText);
 223             return;
 224         }
 225         // Calculate and display
 226         calcBip32RootKeyFromBase58(rootKeyBase58);
 227         calcForDerivationPath();
 228         hidePending();
 229     }
 230
 231     function calcForDerivationPath() {
 232         showPending();
 233         hideValidationError();
 234         // Get the derivation path
 235         var derivationPath = getDerivationPath();
 236         var errorText = findDerivationPathErrors(derivationPath);
 237         if (errorText) {
 238             showValidationError(errorText);
 239             return;
 240         }
 241         bip32ExtendedKey = calcBip32ExtendedKey(derivationPath);
 242         displayBip32Info();
 243         hidePending();
 244     }
 245
 246     function generateClicked() {
 247         if (isUsingOwnEntropy()) {
 248             return;
 249         }
 250         clearDisplay();
 251         showPending();
 252         setTimeout(function() {
 253             setMnemonicLanguage();
 254             var phrase = generateRandomPhrase();
 255             if (!phrase) {
 256                 return;
 257             }
 258             phraseChanged();
 259         }, 50);
 260     }
 261
 262     function languageChanged() {
 263         setTimeout(function() {
 264             setMnemonicLanguage();
 265             if (DOM.phrase.val().length > 0) {
 266                 var newPhrase = convertPhraseToNewLanguage();
 267                 DOM.phrase.val(newPhrase);
 268                 phraseChanged();
 269             }
 270             else {
 271                 DOM.generate.trigger("click");
 272             }
 273         }, 50);
 274     }
 275
 276     function toggleIndexes() {
 277         showIndex = !showIndex;
 278         $("td.index span").toggleClass("invisible");
 279     }
 280
 281     function toggleAddresses() {
 282         showAddress = !showAddress;
 283         $("td.address span").toggleClass("invisible");
 284     }
 285
 286     function togglePublicKeys() {
 287         showPubKey = !showPubKey;
 288         $("td.pubkey span").toggleClass("invisible");
 289     }
 290
 291     function togglePrivateKeys() {
 292         showPrivKey = !showPrivKey;
 293         $("td.privkey span").toggleClass("invisible");
 294     }
 295
 296     // Private methods
 297
 298     function generateRandomPhrase() {
 299         if (!hasStrongRandom()) {
 300             var errorText = "This browser does not support strong randomness";
 301             showValidationError(errorText);
 302             return;
 303         }
 304         var numWords = parseInt(DOM.generatedStrength.val());
 305         var strength = numWords / 3 * 32;
 306         var words = mnemonic.generate(strength);
 307         DOM.phrase.val(words);
 308         return words;
 309     }
 310
 311     function calcBip32RootKeyFromSeed(phrase, passphrase) {
 312         seed = mnemonic.toSeed(phrase, passphrase);
 313         bip32RootKey = bitcoin.HDNode.fromSeedHex(seed, network);
 314     }
 315
 316     function calcBip32RootKeyFromBase58(rootKeyBase58) {
 317         bip32RootKey = bitcoin.HDNode.fromBase58(rootKeyBase58, network);
 318     }
 319
 320     function calcBip32ExtendedKey(path) {
 321         var extendedKey = bip32RootKey;
 322         // Derive the key from the path
 323         var pathBits = path.split("/");
 324         for (var i=0; i<pathBits.length; i++) {
 325             var bit = pathBits[i];
 326             var index = parseInt(bit);
 327             if (isNaN(index)) {
 328                 continue;
 329             }
 330             var hardened = bit[bit.length-1] == "'";
 331             if (hardened) {
 332                 extendedKey = extendedKey.deriveHardened(index);
 333             }
 334             else {
 335                 extendedKey = extendedKey.derive(index);
 336             }
 337         }
 338         return extendedKey
 339     }
 340
 341     function showValidationError(errorText) {
 342         DOM.feedback
 343             .text(errorText)
 344             .show();
 345     }
 346
 347     function hideValidationError() {
 348         DOM.feedback
 349             .text("")
 350             .hide();
 351     }
 352
 353     function findPhraseErrors(phrase) {
 354         // Preprocess the words
 355         phrase = mnemonic.normalizeString(phrase);
 356         var words = phraseToWordArray(phrase);
 357         // Detect blank phrase
 358         if (words.length == 0) {
 359             return "Blank mnemonic";
 360         }
 361         // Check each word
 362         for (var i=0; i<words.length; i++) {
 363             var word = words[i];
 364             var language = getLanguage();
 365             if (WORDLISTS[language].indexOf(word) == -1) {
 366                 console.log("Finding closest match to " + word);
 367                 var nearestWord = findNearestWord(word);
 368                 return word + " not in wordlist, did you mean " + nearestWord + "?";
 369             }
 370         }
 371         // Check the words are valid
 372         var properPhrase = wordArrayToPhrase(words);
 373         var isValid = mnemonic.check(properPhrase);
 374         if (!isValid) {
 375             return "Invalid mnemonic";
 376         }
 377         return false;
 378     }
 379
 380     function validateRootKey(rootKeyBase58) {
 381         try {
 382             bitcoin.HDNode.fromBase58(rootKeyBase58);
 383         }
 384         catch (e) {
 385             return "Invalid root key";
 386         }
 387         return "";
 388     }
 389
 390     function getDerivationPath() {
 391         if (bip44TabSelected()) {
 392             var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
 393             var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
 394             var account = parseIntNoNaN(DOM.bip44account.val(), 0);
 395             var change = parseIntNoNaN(DOM.bip44change.val(), 0);
 396             var path = "m/";
 397             path += purpose + "'/";
 398             path += coin + "'/";
 399             path += account + "'/";
 400             path += change;
 401             DOM.bip44path.val(path);
 402             var derivationPath = DOM.bip44path.val();
 403             console.log("Using derivation path from BIP44 tab: " + derivationPath);
 404             return derivationPath;
 405         }
 406         else if (bip32TabSelected()) {
 407             var derivationPath = DOM.bip32path.val();
 408             console.log("Using derivation path from BIP32 tab: " + derivationPath);
 409             return derivationPath;
 410         }
 411         else {
 412             console.log("Unknown derivation path");
 413         }
 414     }
 415
 416     function findDerivationPathErrors(path) {
 417         // TODO is not perfect but is better than nothing
 418         // Inspired by
 419         // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#test-vectors
 420         // and
 421         // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#extended-keys
 422         var maxDepth = 255; // TODO verify this!!
 423         var maxIndexValue = Math.pow(2, 31); // TODO verify this!!
 424         if (path[0] != "m") {
 425             return "First character must be 'm'";
 426         }
 427         if (path.length > 1) {
 428             if (path[1] != "/") {
 429                 return "Separator must be '/'";
 430             }
 431             var indexes = path.split("/");
 432             if (indexes.length > maxDepth) {
 433                 return "Derivation depth is " + indexes.length + ", must be less than " + maxDepth;
 434             }
 435             for (var depth = 1; depth<indexes.length; depth++) {
 436                 var index = indexes[depth];
 437                 var invalidChars = index.replace(/^[0-9]+'?$/g, "")
 438                 if (invalidChars.length > 0) {
 439                     return "Invalid characters " + invalidChars + " found at depth " + depth;
 440                 }
 441                 var indexValue = parseInt(index.replace("'", ""));
 442                 if (isNaN(depth)) {
 443                     return "Invalid number at depth " + depth;
 444                 }
 445                 if (indexValue > maxIndexValue) {
 446                     return "Value of " + indexValue + " at depth " + depth + " must be less than " + maxIndexValue;
 447                 }
 448             }
 449         }
 450         return false;
 451     }
 452
 453     function displayBip32Info() {
 454         // Display the key
 455         DOM.seed.val(seed);
 456         var rootKey = bip32RootKey.toBase58();
 457         DOM.rootKey.val(rootKey);
 458         var extendedPrivKey = bip32ExtendedKey.toBase58();
 459         DOM.extendedPrivKey.val(extendedPrivKey);
 460         var extendedPubKey = bip32ExtendedKey.toBase58(false);
 461         DOM.extendedPubKey.val(extendedPubKey);
 462         // Display the addresses and privkeys
 463         clearAddressesList();
 464         displayAddresses(0, 20);
 465     }
 466
 467     function displayAddresses(start, total) {
 468         for (var i=0; i<total; i++) {
 469             var index = i + start;
 470             new TableRow(index);
 471         }
 472     }
 473
 474     function TableRow(index) {
 475
 476         var useHardenedAddresses = DOM.hardenedAddresses.prop("checked");
 477
 478         function init() {
 479             calculateValues();
 480         }
 481
 482         function calculateValues() {
 483             setTimeout(function() {
 484                 var key = "";
 485                 if (useHardenedAddresses) {
 486                     key = bip32ExtendedKey.deriveHardened(index);
 487                 }
 488                 else {
 489                     key = bip32ExtendedKey.derive(index);
 490                 }
 491                 var address = key.getAddress().toString();
 492                 var privkey = key.privKey.toWIF(network);
 493                 var pubkey = key.pubKey.toHex();
 494                 var indexText = getDerivationPath() + "/" + index;
 495                 if (useHardenedAddresses) {
 496                     indexText = indexText + "'";
 497                 }
 498                 addAddressToList(indexText, address, pubkey, privkey);
 499             }, 50)
 500         }
 501
 502         init();
 503
 504     }
 505
 506     function showMore() {
 507         var start = DOM.addresses.children().length;
 508         var rowsToAdd = parseInt(DOM.rowsToAdd.val());
 509         if (isNaN(rowsToAdd)) {
 510             rowsToAdd = 20;
 511             DOM.rowsToAdd.val("20");
 512         }
 513         if (rowsToAdd > 200) {
 514             var msg = "Generating " + rowsToAdd + " rows could take a while. ";
 515             msg += "Do you want to continue?";
 516             if (!confirm(msg)) {
 517                 return;
 518             }
 519         }
 520         displayAddresses(start, rowsToAdd);
 521     }
 522
 523     function clearDisplay() {
 524         clearAddressesList();
 525         clearKey();
 526         hideValidationError();
 527     }
 528
 529     function clearAddressesList() {
 530         DOM.addresses.empty();
 531     }
 532
 533     function clearKey() {
 534         DOM.rootKey.val("");
 535         DOM.extendedPrivKey.val("");
 536         DOM.extendedPubKey.val("");
 537     }
 538
 539     function addAddressToList(indexText, address, pubkey, privkey) {
 540         var row = $(addressRowTemplate.html());
 541         // Elements
 542         var indexCell = row.find(".index span");
 543         var addressCell = row.find(".address span");
 544         var pubkeyCell = row.find(".pubkey span");
 545         var privkeyCell = row.find(".privkey span");
 546         // Content
 547         indexCell.text(indexText);
 548         addressCell.text(address);
 549         pubkeyCell.text(pubkey);
 550         privkeyCell.text(privkey);
 551         // Visibility
 552         if (!showIndex) {
 553             indexCell.addClass("invisible");
 554         }
 555         if (!showAddress) {
 556             addressCell.addClass("invisible");
 557         }
 558         if (!showPubKey) {
 559             pubkeyCell.addClass("invisible");
 560         }
 561         if (!showPrivKey) {
 562             privkeyCell.addClass("invisible");
 563         }
 564         DOM.addresses.append(row);
 565         var rowShowQrEls = row.find("[data-show-qr]");
 566         setQrEvents(rowShowQrEls);
 567     }
 568
 569     function hasStrongRandom() {
 570         return 'crypto' in window && window['crypto'] !== null;
 571     }
 572
 573     function disableForms() {
 574         $("form").on("submit", function(e) {
 575             e.preventDefault();
 576         });
 577     }
 578
 579     function parseIntNoNaN(val, defaultVal) {
 580         var v = parseInt(val);
 581         if (isNaN(v)) {
 582             return defaultVal;
 583         }
 584         return v;
 585     }
 586
 587     function showPending() {
 588         DOM.feedback
 589             .text("Calculating...")
 590             .show();
 591     }
 592
 593     function findNearestWord(word) {
 594         var language = getLanguage();
 595         var words = WORDLISTS[language];
 596         var minDistance = 99;
 597         var closestWord = words[0];
 598         for (var i=0; i<words.length; i++) {
 599             var comparedTo = words[i];
 600             var distance = Levenshtein.get(word, comparedTo);
 601             if (distance < minDistance) {
 602                 closestWord = comparedTo;
 603                 minDistance = distance;
 604             }
 605         }
 606         return closestWord;
 607     }
 608
 609     function hidePending() {
 610         DOM.feedback
 611             .text("")
 612             .hide();
 613     }
 614
 615     function populateNetworkSelect() {
 616         for (var i=0; i<networks.length; i++) {
 617             var network = networks[i];
 618             var option = $("<option>");
 619             option.attr("value", i);
 620             option.text(network.name);
 621             DOM.phraseNetwork.append(option);
 622         }
 623     }
 624
 625     function getLanguage() {
 626         var defaultLanguage = "english";
 627         // Try to get from existing phrase
 628         var language = getLanguageFromPhrase();
 629         // Try to get from url if not from phrase
 630         if (language.length == 0) {
 631             language = getLanguageFromUrl();
 632         }
 633         // Default to English if no other option
 634         if (language.length == 0) {
 635             language = defaultLanguage;
 636         }
 637         return language;
 638     }
 639
 640     function getLanguageFromPhrase(phrase) {
 641         // Check if how many words from existing phrase match a language.
 642         var language = "";
 643         if (!phrase) {
 644             phrase = DOM.phrase.val();
 645         }
 646         if (phrase.length > 0) {
 647             var words = phraseToWordArray(phrase);
 648             var languageMatches = {};
 649             for (l in WORDLISTS) {
 650                 // Track how many words match in this language
 651                 languageMatches[l] = 0;
 652                 for (var i=0; i<words.length; i++) {
 653                     var wordInLanguage = WORDLISTS[l].indexOf(words[i]) > -1;
 654                     if (wordInLanguage) {
 655                         languageMatches[l]++;
 656                     }
 657                 }
 658                 // Find languages with most word matches.
 659                 // This is made difficult due to commonalities between Chinese
 660                 // simplified vs traditional.
 661                 var mostMatches = 0;
 662                 var mostMatchedLanguages = [];
 663                 for (var l in languageMatches) {
 664                     var numMatches = languageMatches[l];
 665                     if (numMatches > mostMatches) {
 666                         mostMatches = numMatches;
 667                         mostMatchedLanguages = [l];
 668                     }
 669                     else if (numMatches == mostMatches) {
 670                         mostMatchedLanguages.push(l);
 671                     }
 672                 }
 673             }
 674             if (mostMatchedLanguages.length > 0) {
 675                 // Use first language and warn if multiple detected
 676                 language = mostMatchedLanguages[0];
 677                 if (mostMatchedLanguages.length > 1) {
 678                     console.warn("Multiple possible languages");
 679                     console.warn(mostMatchedLanguages);
 680                 }
 681             }
 682         }
 683         return language;
 684     }
 685
 686     function getLanguageFromUrl() {
 687         for (var language in WORDLISTS) {
 688             if (window.location.hash.indexOf(language) > -1) {
 689                 return language;
 690             }
 691         }
 692         return "";
 693     }
 694
 695     function setMnemonicLanguage() {
 696         var language = getLanguage();
 697         // Load the bip39 mnemonic generator for this language if required
 698         if (!(language in mnemonics)) {
 699             mnemonics[language] = new Mnemonic(language);
 700         }
 701         mnemonic = mnemonics[language];
 702     }
 703
 704     function convertPhraseToNewLanguage() {
 705         var oldLanguage = getLanguageFromPhrase();
 706         var newLanguage = getLanguageFromUrl();
 707         var oldPhrase = DOM.phrase.val();
 708         var oldWords = phraseToWordArray(oldPhrase);
 709         var newWords = [];
 710         for (var i=0; i<oldWords.length; i++) {
 711             var oldWord = oldWords[i];
 712             var index = WORDLISTS[oldLanguage].indexOf(oldWord);
 713             var newWord = WORDLISTS[newLanguage][index];
 714             newWords.push(newWord);
 715         }
 716         newPhrase = wordArrayToPhrase(newWords);
 717         return newPhrase;
 718     }
 719
 720     // TODO look at jsbip39 - mnemonic.splitWords
 721     function phraseToWordArray(phrase) {
 722         var words = phrase.split(/\s/g);
 723         var noBlanks = [];
 724         for (var i=0; i<words.length; i++) {
 725             var word = words[i];
 726             if (word.length > 0) {
 727                 noBlanks.push(word);
 728             }
 729         }
 730         return noBlanks;
 731     }
 732
 733     // TODO look at jsbip39 - mnemonic.joinWords
 734     function wordArrayToPhrase(words) {
 735         var phrase = words.join(" ");
 736         var language = getLanguageFromPhrase(phrase);
 737         if (language == "japanese") {
 738             phrase = words.join("\u3000");
 739         }
 740         return phrase;
 741     }
 742
 743     function isUsingOwnEntropy() {
 744         return DOM.useEntropy.prop("checked");
 745     }
 746
 747     function setMnemonicFromEntropy() {
 748         clearEntropyFeedback();
 749         // Get entropy value
 750         var entropyStr = DOM.entropy.val();
 751         // Work out minimum base for entropy
 752         var entropy = Entropy.fromString(entropyStr);
 753         if (entropy.binaryStr.length == 0) {
 754             return;
 755         }
 756         // Show entropy details
 757         showEntropyFeedback(entropy);
 758         // Use entropy hash if not using raw entropy
 759         var bits = entropy.binaryStr;
 760         var mnemonicLength = DOM.entropyMnemonicLength.val();
 761         if (mnemonicLength != "raw") {
 762             // Get bits by hashing entropy with SHA256
 763             var hash = sjcl.hash.sha256.hash(entropy.cleanStr);
 764             var hex = sjcl.codec.hex.fromBits(hash);
 765             bits = BigInteger.parse(hex, 16).toString(2);
 766             for (var i=0; i<256-bits.length; i++) {
 767                 bits = "0" + bits;
 768             }
 769             // Truncate hash to suit number of words
 770             mnemonicLength = parseInt(mnemonicLength);
 771             var numberOfBits = 32 * mnemonicLength / 3;
 772             bits = bits.substring(0, numberOfBits);
 773         }
 774         // Discard trailing entropy
 775         var bitsToUse = Math.floor(bits.length / 32) * 32;
 776         var start = bits.length - bitsToUse;
 777         var binaryStr = bits.substring(start);
 778         // Convert entropy string to numeric array
 779         var entropyArr = [];
 780         for (var i=0; i<binaryStr.length / 8; i++) {
 781             var byteAsBits = binaryStr.substring(i*8, i*8+8);
 782             var entropyByte = parseInt(byteAsBits, 2);
 783             entropyArr.push(entropyByte)
 784         }
 785         // Convert entropy array to mnemonic
 786         var phrase = mnemonic.toMnemonic(entropyArr);
 787         // Set the mnemonic in the UI
 788         DOM.phrase.val(phrase);
 789     }
 790
 791     function clearEntropyFeedback() {
 792         DOM.entropyStrength.text("...");
 793         DOM.entropyType.text("");
 794         DOM.entropyWordCount.text("0");
 795         DOM.entropyEventCount.text("0");
 796         DOM.entropyBitsPerEvent.text("0");
 797         DOM.entropyBits.text("0");
 798         DOM.entropyFiltered.html("&nbsp;");
 799         DOM.entropyBinary.html("&nbsp;");
 800     }
 801
 802     function showEntropyFeedback(entropy) {
 803         var numberOfBits = entropy.binaryStr.length;
 804         var strength = "extremely weak";
 805         if (numberOfBits >= 64) {
 806             strength = "very weak";
 807         }
 808         if (numberOfBits >= 96) {
 809             strength = "weak";
 810         }
 811         if (numberOfBits >= 128) {
 812             strength = "strong";
 813         }
 814         if (numberOfBits >= 160) {
 815             strength = "very strong";
 816         }
 817         if (numberOfBits >= 192) {
 818             strength = "extremely strong";
 819         }
 820         // If time to crack is less than one day, and password is considered
 821         // strong or better based on the number of bits, rename strength to
 822         // 'easily cracked'.
 823         try {
 824             var z = zxcvbn(entropy.base.parts.join(""));
 825             var timeToCrack = z.crack_times_seconds.offline_fast_hashing_1e10_per_second;
 826             if (timeToCrack < 86400 && entropy.binaryStr.length >= 128) {
 827                 strength = "easily cracked";
 828                 if (z.feedback.warning != "") {
 829                     strength = strength + " - " + z.feedback.warning;
 830                 };
 831             }
 832         }
 833         catch (e) {
 834             strength = "unknown";
 835             console.log("Error detecting entropy strength with zxcvbn:");
 836             console.log(e);
 837         }
 838         var entropyTypeStr = getEntropyTypeStr(entropy);
 839         var wordCount = Math.floor(numberOfBits / 32) * 3;
 840         var bitsPerEvent = entropy.bitsPerEvent.toFixed(2);
 841         DOM.entropyFiltered.html(entropy.cleanHtml);
 842         DOM.entropyType.text(entropyTypeStr);
 843         DOM.entropyStrength.text(strength);
 844         DOM.entropyEventCount.text(entropy.base.ints.length);
 845         DOM.entropyBits.text(numberOfBits);
 846         DOM.entropyWordCount.text(wordCount);
 847         DOM.entropyBinary.text(entropy.binaryStr);
 848         DOM.entropyBitsPerEvent.text(bitsPerEvent);
 849     }
 850
 851     function getEntropyTypeStr(entropy) {
 852         var typeStr = entropy.base.str;
 853         // Add some detail if these are cards
 854         if (entropy.base.asInt == 52) {
 855             var cardDetail = []; // array of message strings
 856             // Detect duplicates
 857             var dupes = [];
 858             var dupeTracker = {};
 859             for (var i=0; i<entropy.base.parts.length; i++) {
 860                 var card = entropy.base.parts[i];
 861                 var cardUpper = card.toUpperCase();
 862                 if (cardUpper in dupeTracker) {
 863                     dupes.push(card);
 864                 }
 865                 dupeTracker[cardUpper] = true;
 866             }
 867             if (dupes.length > 0) {
 868                 var dupeWord = "duplicates";
 869                 if (dupes.length == 1) {
 870                     dupeWord = "duplicate";
 871                 }
 872                 var msg = dupes.length + " " + dupeWord + ": " + dupes.slice(0,3).join(" ");
 873                 if (dupes.length > 3) {
 874                     msg += "...";
 875                 }
 876                 cardDetail.push(msg);
 877             }
 878             // Detect full deck
 879             var uniqueCards = [];
 880             for (var uniqueCard in dupeTracker) {
 881                 uniqueCards.push(uniqueCard);
 882             }
 883             if (uniqueCards.length == 52) {
 884                 cardDetail.unshift("full deck");
 885             }
 886             // Detect missing cards
 887             var values = "A23456789TJQK";
 888             var suits = "CDHS";
 889             var missingCards = [];
 890             for (var i=0; i<suits.length; i++) {
 891                 for (var j=0; j<values.length; j++) {
 892                     var card = values[j] + suits[i];
 893                     if (!(card in dupeTracker)) {
 894                         missingCards.push(card);
 895                     }
 896                 }
 897             }
 898             // Display missing cards if six or less, ie clearly going for full deck
 899             if (missingCards.length > 0 && missingCards.length <= 6) {
 900                 var msg = missingCards.length + " missing: " + missingCards.slice(0,3).join(" ");
 901                 if (missingCards.length > 3) {
 902                     msg += "...";
 903                 }
 904                 cardDetail.push(msg);
 905             }
 906             // Add card details to typeStr
 907             if (cardDetail.length > 0) {
 908                 typeStr += " (" + cardDetail.join(", ") + ")";
 909             }
 910         }
 911         return typeStr;
 912     }
 913
 914     function setQrEvents(els) {
 915         els.on("mouseenter", createQr);
 916         els.on("mouseleave", destroyQr);
 917         els.on("click", toggleQr);
 918     }
 919
 920     function createQr(e) {
 921         var content = e.target.textContent || e.target.value;
 922         if (content) {
 923             var size = 130;
 924             DOM.qrImage.qrcode({width: size, height: size, text: content});
 925             if (!showQr) {
 926                 DOM.qrImage.addClass("hidden");
 927             }
 928             DOM.qrContainer.removeClass("hidden");
 929         }
 930     }
 931
 932     function destroyQr() {
 933         DOM.qrImage.text("");
 934         DOM.qrContainer.addClass("hidden");
 935     }
 936
 937     function toggleQr() {
 938         showQr = !showQr;
 939         DOM.qrImage.toggleClass("hidden");
 940         DOM.qrHint.toggleClass("hidden");
 941     }
 942
 943     function bip44TabSelected() {
 944         return DOM.bip44tab.hasClass("active");
 945     }
 946
 947     function bip32TabSelected() {
 948         return DOM.bip32tab.hasClass("active");
 949     }
 950
 951     var networks = [
 952         {
 953             name: "Bitcoin",
 954             onSelect: function() {
 955                 network = bitcoin.networks.bitcoin;
 956                 DOM.bip44coin.val(0);
 957             },
 958         },
 959         {
 960             name: "Bitcoin Testnet",
 961             onSelect: function() {
 962                 network = bitcoin.networks.testnet;
 963                 DOM.bip44coin.val(1);
 964             },
 965         },
 966         {
 967             name: "Litecoin",
 968             onSelect: function() {
 969                 network = bitcoin.networks.litecoin;
 970                 DOM.bip44coin.val(2);
 971             },
 972         },
 973         {
 974             name: "Dogecoin",
 975             onSelect: function() {
 976                 network = bitcoin.networks.dogecoin;
 977                 DOM.bip44coin.val(3);
 978             },
 979         },
 980         {
 981             name: "ShadowCash",
 982             onSelect: function() {
 983                 network = bitcoin.networks.shadow;
 984                 DOM.bip44coin.val(35);
 985             },
 986         },
 987         {
 988             name: "ShadowCash Testnet",
 989             onSelect: function() {
 990                 network = bitcoin.networks.shadowtn;
 991                 DOM.bip44coin.val(1);
 992             },
 993         },
 994         {
 995             name: "Viacoin",
 996             onSelect: function() {
 997                 network = bitcoin.networks.viacoin;
 998                 DOM.bip44coin.val(14);
 999             },
1000         },
1001         {
1002             name: "Viacoin Testnet",
1003             onSelect: function() {
1004                 network = bitcoin.networks.viacointestnet;
1005                 DOM.bip44coin.val(1);
1006             },
1007         },
1008         {
1009             name: "Jumbucks",
1010             onSelect: function() {
1011                 network = bitcoin.networks.jumbucks;
1012                 DOM.bip44coin.val(26);
1013             },
1014         },
1015         {
1016             name: "CLAM",
1017             onSelect: function() {
1018                 network = bitcoin.networks.clam;
1019                 DOM.bip44coin.val(23);
1020             },
1021         },
1022         {
1023             name: "DASH",
1024             onSelect: function() {
1025                 network = bitcoin.networks.dash;
1026                 DOM.bip44coin.val(5);
1027             },
1028         },
1029         {
1030             name: "Namecoin",
1031             onSelect: function() {
1032                 network = bitcoin.networks.namecoin;
1033                 DOM.bip44coin.val(7);
1034             },
1035         },
1036         {
1037             name: "Peercoin",
1038             onSelect: function() {
1039                 network = bitcoin.networks.peercoin;
1040                 DOM.bip44coin.val(6);
1041             },
1042         },
1043     ]
1044
1045     init();
1046
1047 })();