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 = bitcoinjs.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 = false;
  17     var litecoinUseLtub = true;
  18
  19     var entropyChangeTimeoutEvent = null;
  20     var phraseChangeTimeoutEvent = null;
  21     var rootKeyChangedTimeoutEvent = null;
  22
  23     var generationProcesses = [];
  24
  25     var DOM = {};
  26     DOM.network = $(".network");
  27     DOM.bip32Client = $("#bip32-client");
  28     DOM.phraseNetwork = $("#network-phrase");
  29     DOM.useEntropy = $(".use-entropy");
  30     DOM.entropyContainer = $(".entropy-container");
  31     DOM.entropy = $(".entropy");
  32     DOM.entropyFiltered = DOM.entropyContainer.find(".filtered");
  33     DOM.entropyType = DOM.entropyContainer.find(".type");
  34     DOM.entropyCrackTime = DOM.entropyContainer.find(".crack-time");
  35     DOM.entropyEventCount = DOM.entropyContainer.find(".event-count");
  36     DOM.entropyBits = DOM.entropyContainer.find(".bits");
  37     DOM.entropyBitsPerEvent = DOM.entropyContainer.find(".bits-per-event");
  38     DOM.entropyWordCount = DOM.entropyContainer.find(".word-count");
  39     DOM.entropyBinary = DOM.entropyContainer.find(".binary");
  40     DOM.entropyWordIndexes = DOM.entropyContainer.find(".word-indexes");
  41     DOM.entropyMnemonicLength = DOM.entropyContainer.find(".mnemonic-length");
  42     DOM.entropyFilterWarning = DOM.entropyContainer.find(".filter-warning");
  43     DOM.phrase = $(".phrase");
  44     DOM.passphrase = $(".passphrase");
  45     DOM.generateContainer = $(".generate-container");
  46     DOM.generate = $(".generate");
  47     DOM.seed = $(".seed");
  48     DOM.rootKey = $(".root-key");
  49     DOM.litecoinLtubContainer = $(".litecoin-ltub-container");
  50     DOM.litecoinUseLtub = $(".litecoin-use-ltub");
  51     DOM.extendedPrivKey = $(".extended-priv-key");
  52     DOM.extendedPubKey = $(".extended-pub-key");
  53     DOM.bip32tab = $("#bip32-tab");
  54     DOM.bip44tab = $("#bip44-tab");
  55     DOM.bip49tab = $("#bip49-tab");
  56     DOM.bip141tab = $("#bip141-tab");
  57     DOM.bip32panel = $("#bip32");
  58     DOM.bip44panel = $("#bip44");
  59     DOM.bip49panel = $("#bip49");
  60     DOM.bip32path = $("#bip32-path");
  61     DOM.bip44path = $("#bip44-path");
  62     DOM.bip44purpose = $("#bip44 .purpose");
  63     DOM.bip44coin = $("#bip44 .coin");
  64     DOM.bip44account = $("#bip44 .account");
  65     DOM.bip44accountXprv = $("#bip44 .account-xprv");
  66     DOM.bip44accountXpub = $("#bip44 .account-xpub");
  67     DOM.bip44change = $("#bip44 .change");
  68     DOM.bip49unavailable = $("#bip49 .unavailable");
  69     DOM.bip49available = $("#bip49 .available");
  70     DOM.bip49path = $("#bip49-path");
  71     DOM.bip49purpose = $("#bip49 .purpose");
  72     DOM.bip49coin = $("#bip49 .coin");
  73     DOM.bip49account = $("#bip49 .account");
  74     DOM.bip49accountXprv = $("#bip49 .account-xprv");
  75     DOM.bip49accountXpub = $("#bip49 .account-xpub");
  76     DOM.bip49change = $("#bip49 .change");
  77     DOM.bip141unavailable = $("#bip141 .unavailable");
  78     DOM.bip141available = $("#bip141 .available");
  79     DOM.bip141path = $("#bip141-path");
  80     DOM.bip141semantics = $(".bip141-semantics");
  81     DOM.generatedStrength = $(".generate-container .strength");
  82     DOM.hardenedAddresses = $(".hardened-addresses");
  83     DOM.useBitpayAddressesContainer = $(".use-bitpay-addresses-container");
  84     DOM.useBitpayAddresses = $(".use-bitpay-addresses");
  85     DOM.addresses = $(".addresses");
  86     DOM.rowsToAdd = $(".rows-to-add");
  87     DOM.more = $(".more");
  88     DOM.moreRowsStartIndex = $(".more-rows-start-index");
  89     DOM.feedback = $(".feedback");
  90     DOM.tab = $(".derivation-type a");
  91     DOM.indexToggle = $(".index-toggle");
  92     DOM.addressToggle = $(".address-toggle");
  93     DOM.publicKeyToggle = $(".public-key-toggle");
  94     DOM.privateKeyToggle = $(".private-key-toggle");
  95     DOM.languages = $(".languages a");
  96     DOM.qrContainer = $(".qr-container");
  97     DOM.qrHider = DOM.qrContainer.find(".qr-hider");
  98     DOM.qrImage = DOM.qrContainer.find(".qr-image");
  99     DOM.qrHint = DOM.qrContainer.find(".qr-hint");
 100     DOM.showQrEls = $("[data-show-qr]");
 101
 102     function init() {
 103         // Events
 104         DOM.network.on("change", networkChanged);
 105         DOM.bip32Client.on("change", bip32ClientChanged);
 106         DOM.useEntropy.on("change", setEntropyVisibility);
 107         DOM.entropy.on("input", delayedEntropyChanged);
 108         DOM.entropyMnemonicLength.on("change", entropyChanged);
 109         DOM.phrase.on("input", delayedPhraseChanged);
 110         DOM.passphrase.on("input", delayedPhraseChanged);
 111         DOM.generate.on("click", generateClicked);
 112         DOM.more.on("click", showMore);
 113         DOM.rootKey.on("input", delayedRootKeyChanged);
 114         DOM.litecoinUseLtub.on("change", litecoinUseLtubChanged);
 115         DOM.bip32path.on("input", calcForDerivationPath);
 116         DOM.bip44account.on("input", calcForDerivationPath);
 117         DOM.bip44change.on("input", calcForDerivationPath);
 118         DOM.bip49account.on("input", calcForDerivationPath);
 119         DOM.bip49change.on("input", calcForDerivationPath);
 120         DOM.bip141path.on("input", calcForDerivationPath);
 121         DOM.bip141semantics.on("change", tabChanged);
 122         DOM.tab.on("shown.bs.tab", tabChanged);
 123         DOM.hardenedAddresses.on("change", calcForDerivationPath);
 124         DOM.indexToggle.on("click", toggleIndexes);
 125         DOM.addressToggle.on("click", toggleAddresses);
 126         DOM.publicKeyToggle.on("click", togglePublicKeys);
 127         DOM.privateKeyToggle.on("click", togglePrivateKeys);
 128         DOM.languages.on("click", languageChanged);
 129         DOM.useBitpayAddresses.on("change", useBitpayAddressesChange);
 130         setQrEvents(DOM.showQrEls);
 131         disableForms();
 132         hidePending();
 133         hideValidationError();
 134         populateNetworkSelect();
 135         populateClientSelect();
 136     }
 137
 138     // Event handlers
 139
 140     function networkChanged(e) {
 141         clearDerivedKeys();
 142         clearAddressesList();
 143         DOM.litecoinLtubContainer.addClass("hidden");
 144         DOM.useBitpayAddressesContainer.addClass("hidden");
 145         var networkIndex = e.target.value;
 146         var network = networks[networkIndex];
 147         network.onSelect();
 148         if (network.segwitAvailable) {
 149             adjustNetworkForSegwit();
 150             showSegwitAvailable();
 151         }
 152         else {
 153             showSegwitUnavailable();
 154         }
 155         if (seed != null) {
 156             phraseChanged();
 157         }
 158         else {
 159             rootKeyChanged();
 160         }
 161     }
 162
 163     function bip32ClientChanged(e) {
 164         var clientIndex = DOM.bip32Client.val();
 165         if (clientIndex == "custom") {
 166             DOM.bip32path.prop("readonly", false);
 167         }
 168         else {
 169             DOM.bip32path.prop("readonly", true);
 170             clients[clientIndex].onSelect();
 171             if (seed != null) {
 172                 phraseChanged();
 173             }
 174             else {
 175                 rootKeyChanged();
 176             }
 177         }
 178     }
 179
 180     function setEntropyVisibility() {
 181         if (isUsingOwnEntropy()) {
 182             DOM.entropyContainer.removeClass("hidden");
 183             DOM.generateContainer.addClass("hidden");
 184             DOM.phrase.prop("readonly", true);
 185             DOM.entropy.focus();
 186             entropyChanged();
 187         }
 188         else {
 189             DOM.entropyContainer.addClass("hidden");
 190             DOM.generateContainer.removeClass("hidden");
 191             DOM.phrase.prop("readonly", false);
 192             hidePending();
 193         }
 194     }
 195
 196     function delayedPhraseChanged() {
 197         hideValidationError();
 198         seed = null;
 199         bip32RootKey = null;
 200         bip32ExtendedKey = null;
 201         clearAddressesList();
 202         showPending();
 203         if (phraseChangeTimeoutEvent != null) {
 204             clearTimeout(phraseChangeTimeoutEvent);
 205         }
 206         phraseChangeTimeoutEvent = setTimeout(phraseChanged, 400);
 207     }
 208
 209     function phraseChanged() {
 210         showPending();
 211         setMnemonicLanguage();
 212         // Get the mnemonic phrase
 213         var phrase = DOM.phrase.val();
 214         var errorText = findPhraseErrors(phrase);
 215         if (errorText) {
 216             showValidationError(errorText);
 217             return;
 218         }
 219         // Calculate and display
 220         var passphrase = DOM.passphrase.val();
 221         calcBip32RootKeyFromSeed(phrase, passphrase);
 222         calcForDerivationPath();
 223         // Show the word indexes
 224         showWordIndexes();
 225     }
 226
 227     function tabChanged() {
 228         showPending();
 229         adjustNetworkForSegwit();
 230         var phrase = DOM.phrase.val();
 231         if (phrase != "") {
 232             // Calculate and display for mnemonic
 233             var errorText = findPhraseErrors(phrase);
 234             if (errorText) {
 235                 showValidationError(errorText);
 236                 return;
 237             }
 238             // Calculate and display
 239             var passphrase = DOM.passphrase.val();
 240             calcBip32RootKeyFromSeed(phrase, passphrase);
 241         }
 242         else {
 243             // Calculate and display for root key
 244             var rootKeyBase58 = DOM.rootKey.val();
 245             var errorText = validateRootKey(rootKeyBase58);
 246             if (errorText) {
 247                 showValidationError(errorText);
 248                 return;
 249             }
 250             // Calculate and display
 251             calcBip32RootKeyFromBase58(rootKeyBase58);
 252         }
 253         calcForDerivationPath();
 254     }
 255
 256     function delayedEntropyChanged() {
 257         hideValidationError();
 258         showPending();
 259         if (entropyChangeTimeoutEvent != null) {
 260             clearTimeout(entropyChangeTimeoutEvent);
 261         }
 262         entropyChangeTimeoutEvent = setTimeout(entropyChanged, 400);
 263     }
 264
 265     function entropyChanged() {
 266         // If blank entropy, clear mnemonic, addresses, errors
 267         if (DOM.entropy.val().trim().length == 0) {
 268             clearDisplay();
 269             clearEntropyFeedback();
 270             DOM.phrase.val("");
 271             showValidationError("Blank entropy");
 272             return;
 273         }
 274         // Get the current phrase to detect changes
 275         var phrase = DOM.phrase.val();
 276         // Set the phrase from the entropy
 277         setMnemonicFromEntropy();
 278         // Recalc addresses if the phrase has changed
 279         var newPhrase = DOM.phrase.val();
 280         if (newPhrase != phrase) {
 281             if (newPhrase.length == 0) {
 282                 clearDisplay();
 283             }
 284             else {
 285                 phraseChanged();
 286             }
 287         }
 288         else {
 289             hidePending();
 290         }
 291     }
 292
 293     function delayedRootKeyChanged() {
 294         // Warn if there is an existing mnemonic or passphrase.
 295         if (DOM.phrase.val().length > 0 || DOM.passphrase.val().length > 0) {
 296             if (!confirm("This will clear existing mnemonic and passphrase")) {
 297                 DOM.rootKey.val(bip32RootKey);
 298                 return
 299             }
 300         }
 301         hideValidationError();
 302         showPending();
 303         // Clear existing mnemonic and passphrase
 304         DOM.phrase.val("");
 305         DOM.passphrase.val("");
 306         seed = null;
 307         if (rootKeyChangedTimeoutEvent != null) {
 308             clearTimeout(rootKeyChangedTimeoutEvent);
 309         }
 310         rootKeyChangedTimeoutEvent = setTimeout(rootKeyChanged, 400);
 311     }
 312
 313     function rootKeyChanged() {
 314         showPending();
 315         hideValidationError();
 316         var rootKeyBase58 = DOM.rootKey.val();
 317         var errorText = validateRootKey(rootKeyBase58);
 318         if (errorText) {
 319             showValidationError(errorText);
 320             return;
 321         }
 322         // Calculate and display
 323         calcBip32RootKeyFromBase58(rootKeyBase58);
 324         calcForDerivationPath();
 325     }
 326
 327     function litecoinUseLtubChanged() {
 328         litecoinUseLtub = DOM.litecoinUseLtub.prop("checked");
 329         if (litecoinUseLtub) {
 330             network = bitcoinjs.bitcoin.networks.litecoin;
 331         }
 332         else {
 333             network = bitcoinjs.bitcoin.networks.litecoinXprv;
 334         }
 335         phraseChanged();
 336     }
 337
 338     function calcForDerivationPath() {
 339         clearDerivedKeys();
 340         clearAddressesList();
 341         showPending();
 342         // Don't show segwit if it's selected but network doesn't support it
 343         if (segwitSelected() && !networkHasSegwit()) {
 344             return;
 345         }
 346         // Get the derivation path
 347         var derivationPath = getDerivationPath();
 348         var errorText = findDerivationPathErrors(derivationPath);
 349         if (errorText) {
 350             showValidationError(errorText);
 351             return;
 352         }
 353         bip32ExtendedKey = calcBip32ExtendedKey(derivationPath);
 354         if (bip44TabSelected()) {
 355             displayBip44Info();
 356         }
 357         else if (bip49TabSelected()) {
 358             displayBip49Info();
 359         }
 360         displayBip32Info();
 361     }
 362
 363     function generateClicked() {
 364         if (isUsingOwnEntropy()) {
 365             return;
 366         }
 367         clearDisplay();
 368         showPending();
 369         setTimeout(function() {
 370             setMnemonicLanguage();
 371             var phrase = generateRandomPhrase();
 372             if (!phrase) {
 373                 return;
 374             }
 375             phraseChanged();
 376         }, 50);
 377     }
 378
 379     function languageChanged() {
 380         setTimeout(function() {
 381             setMnemonicLanguage();
 382             if (DOM.phrase.val().length > 0) {
 383                 var newPhrase = convertPhraseToNewLanguage();
 384                 DOM.phrase.val(newPhrase);
 385                 phraseChanged();
 386             }
 387             else {
 388                 DOM.generate.trigger("click");
 389             }
 390         }, 50);
 391     }
 392
 393     function useBitpayAddressesChange() {
 394         setBitcoinCashNetworkValues();
 395         phraseChanged();
 396     }
 397
 398     function toggleIndexes() {
 399         showIndex = !showIndex;
 400         $("td.index span").toggleClass("invisible");
 401     }
 402
 403     function toggleAddresses() {
 404         showAddress = !showAddress;
 405         $("td.address span").toggleClass("invisible");
 406     }
 407
 408     function togglePublicKeys() {
 409         showPubKey = !showPubKey;
 410         $("td.pubkey span").toggleClass("invisible");
 411     }
 412
 413     function togglePrivateKeys() {
 414         showPrivKey = !showPrivKey;
 415         $("td.privkey span").toggleClass("invisible");
 416     }
 417
 418     // Private methods
 419
 420     function generateRandomPhrase() {
 421         if (!hasStrongRandom()) {
 422             var errorText = "This browser does not support strong randomness";
 423             showValidationError(errorText);
 424             return;
 425         }
 426         // get the amount of entropy to use
 427         var numWords = parseInt(DOM.generatedStrength.val());
 428         var strength = numWords / 3 * 32;
 429         var buffer = new Uint8Array(strength / 8);
 430         // create secure entropy
 431         var data = crypto.getRandomValues(buffer);
 432         // show the words
 433         var words = mnemonic.toMnemonic(data);
 434         DOM.phrase.val(words);
 435         // show the entropy
 436         var entropyHex = uint8ArrayToHex(data);
 437         DOM.entropy.val(entropyHex);
 438         // ensure entropy fields are consistent with what is being displayed
 439         DOM.entropyMnemonicLength.val("raw");
 440         return words;
 441     }
 442
 443     function calcBip32RootKeyFromSeed(phrase, passphrase) {
 444         seed = mnemonic.toSeed(phrase, passphrase);
 445         bip32RootKey = bitcoinjs.bitcoin.HDNode.fromSeedHex(seed, network);
 446     }
 447
 448     function calcBip32RootKeyFromBase58(rootKeyBase58) {
 449         bip32RootKey = bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, network);
 450     }
 451
 452     function calcBip32ExtendedKey(path) {
 453         // Check there's a root key to derive from
 454         if (!bip32RootKey) {
 455             return bip32RootKey;
 456         }
 457         var extendedKey = bip32RootKey;
 458         // Derive the key from the path
 459         var pathBits = path.split("/");
 460         for (var i=0; i<pathBits.length; i++) {
 461             var bit = pathBits[i];
 462             var index = parseInt(bit);
 463             if (isNaN(index)) {
 464                 continue;
 465             }
 466             var hardened = bit[bit.length-1] == "'";
 467             var isPriv = !(extendedKey.isNeutered());
 468             var invalidDerivationPath = hardened && !isPriv;
 469             if (invalidDerivationPath) {
 470                 extendedKey = null;
 471             }
 472             else if (hardened) {
 473                 extendedKey = extendedKey.deriveHardened(index);
 474             }
 475             else {
 476                 extendedKey = extendedKey.derive(index);
 477             }
 478         }
 479         return extendedKey
 480     }
 481
 482     function showValidationError(errorText) {
 483         DOM.feedback
 484             .text(errorText)
 485             .show();
 486     }
 487
 488     function hideValidationError() {
 489         DOM.feedback
 490             .text("")
 491             .hide();
 492     }
 493
 494     function findPhraseErrors(phrase) {
 495         // Preprocess the words
 496         phrase = mnemonic.normalizeString(phrase);
 497         var words = phraseToWordArray(phrase);
 498         // Detect blank phrase
 499         if (words.length == 0) {
 500             return "Blank mnemonic";
 501         }
 502         // Check each word
 503         for (var i=0; i<words.length; i++) {
 504             var word = words[i];
 505             var language = getLanguage();
 506             if (WORDLISTS[language].indexOf(word) == -1) {
 507                 console.log("Finding closest match to " + word);
 508                 var nearestWord = findNearestWord(word);
 509                 return word + " not in wordlist, did you mean " + nearestWord + "?";
 510             }
 511         }
 512         // Check the words are valid
 513         var properPhrase = wordArrayToPhrase(words);
 514         var isValid = mnemonic.check(properPhrase);
 515         if (!isValid) {
 516             return "Invalid mnemonic";
 517         }
 518         return false;
 519     }
 520
 521     function validateRootKey(rootKeyBase58) {
 522         try {
 523             bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, network);
 524         }
 525         catch (e) {
 526             return "Invalid root key";
 527         }
 528         return "";
 529     }
 530
 531     function getDerivationPath() {
 532         if (bip44TabSelected()) {
 533             var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
 534             var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
 535             var account = parseIntNoNaN(DOM.bip44account.val(), 0);
 536             var change = parseIntNoNaN(DOM.bip44change.val(), 0);
 537             var path = "m/";
 538             path += purpose + "'/";
 539             path += coin + "'/";
 540             path += account + "'/";
 541             path += change;
 542             DOM.bip44path.val(path);
 543             var derivationPath = DOM.bip44path.val();
 544             console.log("Using derivation path from BIP44 tab: " + derivationPath);
 545             return derivationPath;
 546         }
 547         else if (bip49TabSelected()) {
 548             var purpose = parseIntNoNaN(DOM.bip49purpose.val(), 49);
 549             var coin = parseIntNoNaN(DOM.bip49coin.val(), 0);
 550             var account = parseIntNoNaN(DOM.bip49account.val(), 0);
 551             var change = parseIntNoNaN(DOM.bip49change.val(), 0);
 552             var path = "m/";
 553             path += purpose + "'/";
 554             path += coin + "'/";
 555             path += account + "'/";
 556             path += change;
 557             DOM.bip49path.val(path);
 558             var derivationPath = DOM.bip49path.val();
 559             console.log("Using derivation path from BIP49 tab: " + derivationPath);
 560             return derivationPath;
 561         }
 562         else if (bip32TabSelected()) {
 563             var derivationPath = DOM.bip32path.val();
 564             console.log("Using derivation path from BIP32 tab: " + derivationPath);
 565             return derivationPath;
 566         }
 567         else if (bip141TabSelected()) {
 568             var derivationPath = DOM.bip141path.val();
 569             console.log("Using derivation path from BIP141 tab: " + derivationPath);
 570             return derivationPath;
 571         }
 572         else {
 573             console.log("Unknown derivation path");
 574         }
 575     }
 576
 577     function findDerivationPathErrors(path) {
 578         // TODO is not perfect but is better than nothing
 579         // Inspired by
 580         // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#test-vectors
 581         // and
 582         // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#extended-keys
 583         var maxDepth = 255; // TODO verify this!!
 584         var maxIndexValue = Math.pow(2, 31); // TODO verify this!!
 585         if (path[0] != "m") {
 586             return "First character must be 'm'";
 587         }
 588         if (path.length > 1) {
 589             if (path[1] != "/") {
 590                 return "Separator must be '/'";
 591             }
 592             var indexes = path.split("/");
 593             if (indexes.length > maxDepth) {
 594                 return "Derivation depth is " + indexes.length + ", must be less than " + maxDepth;
 595             }
 596             for (var depth = 1; depth<indexes.length; depth++) {
 597                 var index = indexes[depth];
 598                 var invalidChars = index.replace(/^[0-9]+'?$/g, "")
 599                 if (invalidChars.length > 0) {
 600                     return "Invalid characters " + invalidChars + " found at depth " + depth;
 601                 }
 602                 var indexValue = parseInt(index.replace("'", ""));
 603                 if (isNaN(depth)) {
 604                     return "Invalid number at depth " + depth;
 605                 }
 606                 if (indexValue > maxIndexValue) {
 607                     return "Value of " + indexValue + " at depth " + depth + " must be less than " + maxIndexValue;
 608                 }
 609             }
 610         }
 611         // Check root key exists or else derivation path is useless!
 612         if (!bip32RootKey) {
 613             return "No root key";
 614         }
 615         // Check no hardened derivation path when using xpub keys
 616         var hardenedPath = path.indexOf("'") > -1;
 617         var hardenedAddresses = bip32TabSelected() && DOM.hardenedAddresses.prop("checked");
 618         var hardened = hardenedPath || hardenedAddresses;
 619         var isXpubkey = bip32RootKey.isNeutered();
 620         if (hardened && isXpubkey) {
 621             return "Hardened derivation path is invalid with xpub key";
 622         }
 623         return false;
 624     }
 625
 626     function displayBip44Info() {
 627         // Get the derivation path for the account
 628         var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
 629         var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
 630         var account = parseIntNoNaN(DOM.bip44account.val(), 0);
 631         var path = "m/";
 632         path += purpose + "'/";
 633         path += coin + "'/";
 634         path += account + "'/";
 635         // Calculate the account extended keys
 636         var accountExtendedKey = calcBip32ExtendedKey(path);
 637         var accountXprv = accountExtendedKey.toBase58();
 638         var accountXpub = accountExtendedKey.neutered().toBase58();
 639         // Display the extended keys
 640         DOM.bip44accountXprv.val(accountXprv);
 641         DOM.bip44accountXpub.val(accountXpub);
 642     }
 643
 644     function displayBip49Info() {
 645         // Get the derivation path for the account
 646         var purpose = parseIntNoNaN(DOM.bip49purpose.val(), 49);
 647         var coin = parseIntNoNaN(DOM.bip49coin.val(), 0);
 648         var account = parseIntNoNaN(DOM.bip49account.val(), 0);
 649         var path = "m/";
 650         path += purpose + "'/";
 651         path += coin + "'/";
 652         path += account + "'/";
 653         // Calculate the account extended keys
 654         var accountExtendedKey = calcBip32ExtendedKey(path);
 655         var accountXprv = accountExtendedKey.toBase58();
 656         var accountXpub = accountExtendedKey.neutered().toBase58();
 657         // Display the extended keys
 658         DOM.bip49accountXprv.val(accountXprv);
 659         DOM.bip49accountXpub.val(accountXpub);
 660     }
 661
 662     function displayBip32Info() {
 663         // Display the key
 664         DOM.seed.val(seed);
 665         var rootKey = bip32RootKey.toBase58();
 666         DOM.rootKey.val(rootKey);
 667         var xprvkeyB58 = "NA";
 668         if (!bip32ExtendedKey.isNeutered()) {
 669             xprvkeyB58 = bip32ExtendedKey.toBase58();
 670         }
 671         var extendedPrivKey = xprvkeyB58;
 672         DOM.extendedPrivKey.val(extendedPrivKey);
 673         var extendedPubKey = bip32ExtendedKey.neutered().toBase58();
 674         DOM.extendedPubKey.val(extendedPubKey);
 675         // Display the addresses and privkeys
 676         clearAddressesList();
 677         displayAddresses(0, 20);
 678     }
 679
 680     function displayAddresses(start, total) {
 681         generationProcesses.push(new (function() {
 682
 683             var rows = [];
 684
 685             this.stop = function() {
 686                 for (var i=0; i<rows.length; i++) {
 687                     rows[i].shouldGenerate = false;
 688                 }
 689                 hidePending();
 690             }
 691
 692             for (var i=0; i<total; i++) {
 693                 var index = i + start;
 694                 var isLast = i == total - 1;
 695                 rows.push(new TableRow(index, isLast));
 696             }
 697
 698         })());
 699     }
 700
 701     function segwitSelected() {
 702         return bip49TabSelected() || bip141TabSelected();
 703     }
 704
 705     function p2wpkhSelected() {
 706         return bip141TabSelected() && DOM.bip141semantics.val() == "p2wpkh";
 707     }
 708
 709     function p2wpkhInP2shSelected() {
 710         return bip49TabSelected() ||
 711             (bip141TabSelected() && DOM.bip141semantics.val() == "p2wpkh-p2sh");
 712     }
 713
 714     function TableRow(index, isLast) {
 715
 716         var self = this;
 717         this.shouldGenerate = true;
 718         var useHardenedAddresses = DOM.hardenedAddresses.prop("checked");
 719         var isSegwit = segwitSelected();
 720         var segwitAvailable = networkHasSegwit();
 721         var isP2wpkh = p2wpkhSelected();
 722         var isP2wpkhInP2sh = p2wpkhInP2shSelected();
 723
 724         function init() {
 725             calculateValues();
 726         }
 727
 728         function calculateValues() {
 729             setTimeout(function() {
 730                 if (!self.shouldGenerate) {
 731                     return;
 732                 }
 733                 var key = "NA";
 734                 if (useHardenedAddresses) {
 735                     key = bip32ExtendedKey.deriveHardened(index);
 736                 }
 737                 else {
 738                     key = bip32ExtendedKey.derive(index);
 739                 }
 740                 var address = key.getAddress().toString();
 741                 var privkey = "NA";
 742                 if (!key.isNeutered()) {
 743                     privkey = key.keyPair.toWIF(network);
 744                 }
 745                 var pubkey = key.getPublicKeyBuffer().toString('hex');
 746                 var indexText = getDerivationPath() + "/" + index;
 747                 if (useHardenedAddresses) {
 748                     indexText = indexText + "'";
 749                 }
 750                 // Ethereum values are different
 751                 if (networks[DOM.network.val()].name == "ETH - Ethereum") {
 752                     var privKeyBuffer = key.keyPair.d.toBuffer();
 753                     privkey = privKeyBuffer.toString('hex');
 754                     var addressBuffer = ethUtil.privateToAddress(privKeyBuffer);
 755                     var hexAddress = addressBuffer.toString('hex');
 756                     var checksumAddress = ethUtil.toChecksumAddress(hexAddress);
 757                     address = ethUtil.addHexPrefix(checksumAddress);
 758                     privkey = ethUtil.addHexPrefix(privkey);
 759                     pubkey = ethUtil.addHexPrefix(pubkey);
 760                 }
 761                 // Ripple values are different
 762                 if (networks[DOM.network.val()].name == "XRP - Ripple") {
 763                     privkey = convertRipplePriv(privkey);
 764                     address = convertRippleAdrr(address);
 765                 }
 766                 // Segwit addresses are different
 767                 if (isSegwit) {
 768                     if (!segwitAvailable) {
 769                         return;
 770                     }
 771                     if (isP2wpkh) {
 772                         var keyhash = bitcoinjs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
 773                         var scriptpubkey = bitcoinjs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
 774                         address = bitcoinjs.bitcoin.address.fromOutputScript(scriptpubkey, network)
 775                     }
 776                     else if (isP2wpkhInP2sh) {
 777                         var keyhash = bitcoinjs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
 778                         var scriptsig = bitcoinjs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
 779                         var addressbytes = bitcoinjs.bitcoin.crypto.hash160(scriptsig);
 780                         var scriptpubkey = bitcoinjs.bitcoin.script.scriptHash.output.encode(addressbytes);
 781                         address = bitcoinjs.bitcoin.address.fromOutputScript(scriptpubkey, network)
 782                     }
 783                 }
 784                 addAddressToList(indexText, address, pubkey, privkey);
 785                 if (isLast) {
 786                     hidePending();
 787                 }
 788             }, 50)
 789         }
 790
 791         init();
 792
 793     }
 794
 795     function showMore() {
 796         var rowsToAdd = parseInt(DOM.rowsToAdd.val());
 797         if (isNaN(rowsToAdd)) {
 798             rowsToAdd = 20;
 799             DOM.rowsToAdd.val("20");
 800         }
 801         var start = parseInt(DOM.moreRowsStartIndex.val())
 802         if (isNaN(start)) {
 803             start = lastIndexInTable() + 1;
 804         }
 805         else {
 806             var newStart = start + rowsToAdd;
 807             DOM.moreRowsStartIndex.val(newStart);
 808         }
 809         if (rowsToAdd > 200) {
 810             var msg = "Generating " + rowsToAdd + " rows could take a while. ";
 811             msg += "Do you want to continue?";
 812             if (!confirm(msg)) {
 813                 return;
 814             }
 815         }
 816         displayAddresses(start, rowsToAdd);
 817     }
 818
 819     function clearDisplay() {
 820         clearAddressesList();
 821         clearKeys();
 822         hideValidationError();
 823     }
 824
 825     function clearAddressesList() {
 826         DOM.addresses.empty();
 827         stopGenerating();
 828     }
 829
 830     function stopGenerating() {
 831         while (generationProcesses.length > 0) {
 832             var generation = generationProcesses.shift();
 833             generation.stop();
 834         }
 835     }
 836
 837     function clearKeys() {
 838         clearRootKey();
 839         clearDerivedKeys();
 840     }
 841
 842     function clearRootKey() {
 843         DOM.rootKey.val("");
 844     }
 845
 846     function clearDerivedKeys() {
 847         DOM.extendedPrivKey.val("");
 848         DOM.extendedPubKey.val("");
 849         DOM.bip44accountXprv.val("");
 850         DOM.bip44accountXpub.val("");
 851     }
 852
 853     function addAddressToList(indexText, address, pubkey, privkey) {
 854         var row = $(addressRowTemplate.html());
 855         // Elements
 856         var indexCell = row.find(".index span");
 857         var addressCell = row.find(".address span");
 858         var pubkeyCell = row.find(".pubkey span");
 859         var privkeyCell = row.find(".privkey span");
 860         // Content
 861         indexCell.text(indexText);
 862         addressCell.text(address);
 863         pubkeyCell.text(pubkey);
 864         privkeyCell.text(privkey);
 865         // Visibility
 866         if (!showIndex) {
 867             indexCell.addClass("invisible");
 868         }
 869         if (!showAddress) {
 870             addressCell.addClass("invisible");
 871         }
 872         if (!showPubKey) {
 873             pubkeyCell.addClass("invisible");
 874         }
 875         if (!showPrivKey) {
 876             privkeyCell.addClass("invisible");
 877         }
 878         DOM.addresses.append(row);
 879         var rowShowQrEls = row.find("[data-show-qr]");
 880         setQrEvents(rowShowQrEls);
 881     }
 882
 883     function hasStrongRandom() {
 884         return 'crypto' in window && window['crypto'] !== null;
 885     }
 886
 887     function disableForms() {
 888         $("form").on("submit", function(e) {
 889             e.preventDefault();
 890         });
 891     }
 892
 893     function parseIntNoNaN(val, defaultVal) {
 894         var v = parseInt(val);
 895         if (isNaN(v)) {
 896             return defaultVal;
 897         }
 898         return v;
 899     }
 900
 901     function showPending() {
 902         DOM.feedback
 903             .text("Calculating...")
 904             .show();
 905     }
 906
 907     function findNearestWord(word) {
 908         var language = getLanguage();
 909         var words = WORDLISTS[language];
 910         var minDistance = 99;
 911         var closestWord = words[0];
 912         for (var i=0; i<words.length; i++) {
 913             var comparedTo = words[i];
 914             if (comparedTo.indexOf(word) == 0) {
 915                 return comparedTo;
 916             }
 917             var distance = Levenshtein.get(word, comparedTo);
 918             if (distance < minDistance) {
 919                 closestWord = comparedTo;
 920                 minDistance = distance;
 921             }
 922         }
 923         return closestWord;
 924     }
 925
 926     function hidePending() {
 927         DOM.feedback
 928             .text("")
 929             .hide();
 930     }
 931
 932     function populateNetworkSelect() {
 933         for (var i=0; i<networks.length; i++) {
 934             var network = networks[i];
 935             var option = $("<option>");
 936             option.attr("value", i);
 937             option.text(network.name);
 938             if (network.name == "BTC - Bitcoin") {
 939                 option.prop("selected", true);
 940             }
 941             DOM.phraseNetwork.append(option);
 942         }
 943     }
 944
 945     function populateClientSelect() {
 946         for (var i=0; i<clients.length; i++) {
 947             var client = clients[i];
 948             var option = $("<option>");
 949             option.attr("value", i);
 950             option.text(client.name);
 951             DOM.bip32Client.append(option);
 952         }
 953     }
 954
 955     function getLanguage() {
 956         var defaultLanguage = "english";
 957         // Try to get from existing phrase
 958         var language = getLanguageFromPhrase();
 959         // Try to get from url if not from phrase
 960         if (language.length == 0) {
 961             language = getLanguageFromUrl();
 962         }
 963         // Default to English if no other option
 964         if (language.length == 0) {
 965             language = defaultLanguage;
 966         }
 967         return language;
 968     }
 969
 970     function getLanguageFromPhrase(phrase) {
 971         // Check if how many words from existing phrase match a language.
 972         var language = "";
 973         if (!phrase) {
 974             phrase = DOM.phrase.val();
 975         }
 976         if (phrase.length > 0) {
 977             var words = phraseToWordArray(phrase);
 978             var languageMatches = {};
 979             for (l in WORDLISTS) {
 980                 // Track how many words match in this language
 981                 languageMatches[l] = 0;
 982                 for (var i=0; i<words.length; i++) {
 983                     var wordInLanguage = WORDLISTS[l].indexOf(words[i]) > -1;
 984                     if (wordInLanguage) {
 985                         languageMatches[l]++;
 986                     }
 987                 }
 988                 // Find languages with most word matches.
 989                 // This is made difficult due to commonalities between Chinese
 990                 // simplified vs traditional.
 991                 var mostMatches = 0;
 992                 var mostMatchedLanguages = [];
 993                 for (var l in languageMatches) {
 994                     var numMatches = languageMatches[l];
 995                     if (numMatches > mostMatches) {
 996                         mostMatches = numMatches;
 997                         mostMatchedLanguages = [l];
 998                     }
 999                     else if (numMatches == mostMatches) {
1000                         mostMatchedLanguages.push(l);
1001                     }
1002                 }
1003             }
1004             if (mostMatchedLanguages.length > 0) {
1005                 // Use first language and warn if multiple detected
1006                 language = mostMatchedLanguages[0];
1007                 if (mostMatchedLanguages.length > 1) {
1008                     console.warn("Multiple possible languages");
1009                     console.warn(mostMatchedLanguages);
1010                 }
1011             }
1012         }
1013         return language;
1014     }
1015
1016     function getLanguageFromUrl() {
1017         for (var language in WORDLISTS) {
1018             if (window.location.hash.indexOf(language) > -1) {
1019                 return language;
1020             }
1021         }
1022         return "";
1023     }
1024
1025     function setMnemonicLanguage() {
1026         var language = getLanguage();
1027         // Load the bip39 mnemonic generator for this language if required
1028         if (!(language in mnemonics)) {
1029             mnemonics[language] = new Mnemonic(language);
1030         }
1031         mnemonic = mnemonics[language];
1032     }
1033
1034     function convertPhraseToNewLanguage() {
1035         var oldLanguage = getLanguageFromPhrase();
1036         var newLanguage = getLanguageFromUrl();
1037         var oldPhrase = DOM.phrase.val();
1038         var oldWords = phraseToWordArray(oldPhrase);
1039         var newWords = [];
1040         for (var i=0; i<oldWords.length; i++) {
1041             var oldWord = oldWords[i];
1042             var index = WORDLISTS[oldLanguage].indexOf(oldWord);
1043             var newWord = WORDLISTS[newLanguage][index];
1044             newWords.push(newWord);
1045         }
1046         newPhrase = wordArrayToPhrase(newWords);
1047         return newPhrase;
1048     }
1049
1050     // TODO look at jsbip39 - mnemonic.splitWords
1051     function phraseToWordArray(phrase) {
1052         var words = phrase.split(/\s/g);
1053         var noBlanks = [];
1054         for (var i=0; i<words.length; i++) {
1055             var word = words[i];
1056             if (word.length > 0) {
1057                 noBlanks.push(word);
1058             }
1059         }
1060         return noBlanks;
1061     }
1062
1063     // TODO look at jsbip39 - mnemonic.joinWords
1064     function wordArrayToPhrase(words) {
1065         var phrase = words.join(" ");
1066         var language = getLanguageFromPhrase(phrase);
1067         if (language == "japanese") {
1068             phrase = words.join("\u3000");
1069         }
1070         return phrase;
1071     }
1072
1073     function isUsingOwnEntropy() {
1074         return DOM.useEntropy.prop("checked");
1075     }
1076
1077     function setMnemonicFromEntropy() {
1078         clearEntropyFeedback();
1079         // Get entropy value
1080         var entropyStr = DOM.entropy.val();
1081         // Work out minimum base for entropy
1082         var entropy = Entropy.fromString(entropyStr);
1083         if (entropy.binaryStr.length == 0) {
1084             return;
1085         }
1086         // Show entropy details
1087         showEntropyFeedback(entropy);
1088         // Use entropy hash if not using raw entropy
1089         var bits = entropy.binaryStr;
1090         var mnemonicLength = DOM.entropyMnemonicLength.val();
1091         if (mnemonicLength != "raw") {
1092             // Get bits by hashing entropy with SHA256
1093             var hash = sjcl.hash.sha256.hash(entropy.cleanStr);
1094             var hex = sjcl.codec.hex.fromBits(hash);
1095             bits = BigInteger.parse(hex, 16).toString(2);
1096             while (bits.length % 256 != 0) {
1097                 bits = "0" + bits;
1098             }
1099             // Truncate hash to suit number of words
1100             mnemonicLength = parseInt(mnemonicLength);
1101             var numberOfBits = 32 * mnemonicLength / 3;
1102             bits = bits.substring(0, numberOfBits);
1103         }
1104         // Discard trailing entropy
1105         var bitsToUse = Math.floor(bits.length / 32) * 32;
1106         var start = bits.length - bitsToUse;
1107         var binaryStr = bits.substring(start);
1108         // Convert entropy string to numeric array
1109         var entropyArr = [];
1110         for (var i=0; i<binaryStr.length / 8; i++) {
1111             var byteAsBits = binaryStr.substring(i*8, i*8+8);
1112             var entropyByte = parseInt(byteAsBits, 2);
1113             entropyArr.push(entropyByte)
1114         }
1115         // Convert entropy array to mnemonic
1116         var phrase = mnemonic.toMnemonic(entropyArr);
1117         // Set the mnemonic in the UI
1118         DOM.phrase.val(phrase);
1119         // Show the word indexes
1120         showWordIndexes();
1121     }
1122
1123     function clearEntropyFeedback() {
1124         DOM.entropyCrackTime.text("...");
1125         DOM.entropyType.text("");
1126         DOM.entropyWordCount.text("0");
1127         DOM.entropyEventCount.text("0");
1128         DOM.entropyBitsPerEvent.text("0");
1129         DOM.entropyBits.text("0");
1130         DOM.entropyFiltered.html("&nbsp;");
1131         DOM.entropyBinary.html("&nbsp;");
1132     }
1133
1134     function showEntropyFeedback(entropy) {
1135         var numberOfBits = entropy.binaryStr.length;
1136         var timeToCrack = "unknown";
1137         try {
1138             var z = zxcvbn(entropy.base.parts.join(""));
1139             timeToCrack = z.crack_times_display.offline_fast_hashing_1e10_per_second;
1140             if (z.feedback.warning != "") {
1141                 timeToCrack = timeToCrack + " - " + z.feedback.warning;
1142             };
1143         }
1144         catch (e) {
1145             console.log("Error detecting entropy strength with zxcvbn:");
1146             console.log(e);
1147         }
1148         var entropyTypeStr = getEntropyTypeStr(entropy);
1149         var wordCount = Math.floor(numberOfBits / 32) * 3;
1150         var bitsPerEvent = entropy.bitsPerEvent.toFixed(2);
1151         DOM.entropyFiltered.html(entropy.cleanHtml);
1152         DOM.entropyType.text(entropyTypeStr);
1153         DOM.entropyCrackTime.text(timeToCrack);
1154         DOM.entropyEventCount.text(entropy.base.ints.length);
1155         DOM.entropyBits.text(numberOfBits);
1156         DOM.entropyWordCount.text(wordCount);
1157         DOM.entropyBinary.text(entropy.binaryStr);
1158         DOM.entropyBitsPerEvent.text(bitsPerEvent);
1159         // detect and warn of filtering
1160         var rawNoSpaces = DOM.entropy.val().replace(/\s/g, "");
1161         var cleanNoSpaces = entropy.cleanStr.replace(/\s/g, "");
1162         var isFiltered = rawNoSpaces.length != cleanNoSpaces.length;
1163         if (isFiltered) {
1164             DOM.entropyFilterWarning.removeClass('hidden');
1165         }
1166         else {
1167             DOM.entropyFilterWarning.addClass('hidden');
1168         }
1169     }
1170
1171     function getEntropyTypeStr(entropy) {
1172         var typeStr = entropy.base.str;
1173         // Add some detail if these are cards
1174         if (entropy.base.asInt == 52) {
1175             var cardDetail = []; // array of message strings
1176             // Detect duplicates
1177             var dupes = [];
1178             var dupeTracker = {};
1179             for (var i=0; i<entropy.base.parts.length; i++) {
1180                 var card = entropy.base.parts[i];
1181                 var cardUpper = card.toUpperCase();
1182                 if (cardUpper in dupeTracker) {
1183                     dupes.push(card);
1184                 }
1185                 dupeTracker[cardUpper] = true;
1186             }
1187             if (dupes.length > 0) {
1188                 var dupeWord = "duplicates";
1189                 if (dupes.length == 1) {
1190                     dupeWord = "duplicate";
1191                 }
1192                 var msg = dupes.length + " " + dupeWord + ": " + dupes.slice(0,3).join(" ");
1193                 if (dupes.length > 3) {
1194                     msg += "...";
1195                 }
1196                 cardDetail.push(msg);
1197             }
1198             // Detect full deck
1199             var uniqueCards = [];
1200             for (var uniqueCard in dupeTracker) {
1201                 uniqueCards.push(uniqueCard);
1202             }
1203             if (uniqueCards.length == 52) {
1204                 cardDetail.unshift("full deck");
1205             }
1206             // Detect missing cards
1207             var values = "A23456789TJQK";
1208             var suits = "CDHS";
1209             var missingCards = [];
1210             for (var i=0; i<suits.length; i++) {
1211                 for (var j=0; j<values.length; j++) {
1212                     var card = values[j] + suits[i];
1213                     if (!(card in dupeTracker)) {
1214                         missingCards.push(card);
1215                     }
1216                 }
1217             }
1218             // Display missing cards if six or less, ie clearly going for full deck
1219             if (missingCards.length > 0 && missingCards.length <= 6) {
1220                 var msg = missingCards.length + " missing: " + missingCards.slice(0,3).join(" ");
1221                 if (missingCards.length > 3) {
1222                     msg += "...";
1223                 }
1224                 cardDetail.push(msg);
1225             }
1226             // Add card details to typeStr
1227             if (cardDetail.length > 0) {
1228                 typeStr += " (" + cardDetail.join(", ") + ")";
1229             }
1230         }
1231         return typeStr;
1232     }
1233
1234     function setQrEvents(els) {
1235         els.on("mouseenter", createQr);
1236         els.on("mouseleave", destroyQr);
1237         els.on("click", toggleQr);
1238     }
1239
1240     function createQr(e) {
1241         var content = e.target.textContent || e.target.value;
1242         if (content) {
1243             var qrEl = kjua({
1244                 text: content,
1245                 render: "canvas",
1246                 size: 310,
1247                 ecLevel: 'H',
1248             });
1249             DOM.qrImage.append(qrEl);
1250             if (!showQr) {
1251                 DOM.qrHider.addClass("hidden");
1252             }
1253             else {
1254                 DOM.qrHider.removeClass("hidden");
1255             }
1256             DOM.qrContainer.removeClass("hidden");
1257         }
1258     }
1259
1260     function destroyQr() {
1261         DOM.qrImage.text("");
1262         DOM.qrContainer.addClass("hidden");
1263     }
1264
1265     function toggleQr() {
1266         showQr = !showQr;
1267         DOM.qrHider.toggleClass("hidden");
1268         DOM.qrHint.toggleClass("hidden");
1269     }
1270
1271     function bip44TabSelected() {
1272         return DOM.bip44tab.hasClass("active");
1273     }
1274
1275     function bip32TabSelected() {
1276         return DOM.bip32tab.hasClass("active");
1277     }
1278
1279     function networkHasSegwit() {
1280         return networks[DOM.network.val()].segwitAvailable;
1281     }
1282
1283     function bip49TabSelected() {
1284         return DOM.bip49tab.hasClass("active");
1285     }
1286
1287     function bip141TabSelected() {
1288         return DOM.bip141tab.hasClass("active");
1289     }
1290
1291     function setHdCoin(coinValue) {
1292         DOM.bip44coin.val(coinValue);
1293         DOM.bip49coin.val(coinValue);
1294     }
1295
1296     function showSegwitAvailable() {
1297         DOM.bip49unavailable.addClass("hidden");
1298         DOM.bip49available.removeClass("hidden");
1299         DOM.bip141unavailable.addClass("hidden");
1300         DOM.bip141available.removeClass("hidden");
1301     }
1302
1303     function showSegwitUnavailable() {
1304         DOM.bip49available.addClass("hidden");
1305         DOM.bip49unavailable.removeClass("hidden");
1306         DOM.bip141available.addClass("hidden");
1307         DOM.bip141unavailable.removeClass("hidden");
1308     }
1309
1310     function useBitpayAddresses() {
1311         return !(DOM.useBitpayAddresses.prop("checked"));
1312     }
1313
1314     function setBitcoinCashNetworkValues() {
1315         if (useBitpayAddresses()) {
1316             network = bitcoinjs.bitcoin.networks.bitcoin;
1317         }
1318         else {
1319             network = bitcoinjs.bitcoin.networks.bitcoinCashBitbpay;
1320         }
1321     }
1322
1323     function adjustNetworkForSegwit() {
1324         // If segwit is selected the xpub/xprv prefixes need to be adjusted
1325         // to avoid accidentally importing BIP49 xpub to BIP44 watch only
1326         // wallet.
1327         // See https://github.com/iancoleman/bip39/issues/125
1328         var segwitNetworks = null;
1329         // if a segwit network is alread selected, need to use base network to
1330         // look up new parameters
1331         if ("baseNetwork" in network) {
1332             network = bitcoinjs.bitcoin.networks[network.baseNetwork];
1333         }
1334         // choose the right segwit params
1335         if (p2wpkhSelected() && "p2wpkh" in network) {
1336             network = network.p2wpkh;
1337         }
1338         else if (p2wpkhInP2shSelected() && "p2wpkhInP2sh" in network) {
1339             network = network.p2wpkhInP2sh;
1340         }
1341     }
1342
1343     function lastIndexInTable() {
1344         var pathText = DOM.addresses.find(".index").last().text();
1345         var pathBits = pathText.split("/");
1346         var lastBit = pathBits[pathBits.length-1];
1347         var lastBitClean = lastBit.replace("'", "");
1348         return parseInt(lastBitClean);
1349     }
1350
1351     function uint8ArrayToHex(a) {
1352         var s = ""
1353         for (var i=0; i<a.length; i++) {
1354             var h = a[i].toString(16);
1355             while (h.length < 2) {
1356                 h = "0" + h;
1357             }
1358             s = s + h;
1359         }
1360         return s;
1361     }
1362
1363     function showWordIndexes() {
1364         var phrase = DOM.phrase.val();
1365         var words = phraseToWordArray(phrase);
1366         var wordIndexes = [];
1367         var language = getLanguage();
1368         for (var i=0; i<words.length; i++) {
1369             var word = words[i];
1370             var wordIndex = WORDLISTS[language].indexOf(word);
1371             wordIndexes.push(wordIndex);
1372         }
1373         var wordIndexesStr = wordIndexes.join(", ");
1374         DOM.entropyWordIndexes.text(wordIndexesStr);
1375     }
1376
1377     var networks = [
1378         {
1379             name: "BCH - Bitcoin Cash",
1380             segwitAvailable: false,
1381             onSelect: function() {
1382                 DOM.useBitpayAddressesContainer.removeClass("hidden");
1383                 setBitcoinCashNetworkValues();
1384                 setHdCoin(145);
1385             },
1386         },
1387         {
1388             name: "BTC - Bitcoin",
1389             segwitAvailable: true,
1390             onSelect: function() {
1391                 network = bitcoinjs.bitcoin.networks.bitcoin;
1392                 setHdCoin(0);
1393             },
1394         },
1395         {
1396             name: "BTC - Bitcoin Testnet",
1397             segwitAvailable: true,
1398             onSelect: function() {
1399                 network = bitcoinjs.bitcoin.networks.testnet;
1400                 setHdCoin(1);
1401             },
1402         },
1403         {
1404             name: "BTG - Bitcoin Gold",
1405             segwitAvailable: true,
1406             onSelect: function() {
1407                 network = bitcoinjs.bitcoin.networks.bgold;
1408                 setHdCoin(0);
1409             },
1410         },
1411         {
1412             name: "CLAM - Clams",
1413             segwitAvailable: false,
1414             onSelect: function() {
1415                 network = bitcoinjs.bitcoin.networks.clam;
1416                 setHdCoin(23);
1417             },
1418         },
1419         {
1420             name: "CRW - Crown",
1421             segwitAvailable: false,
1422             onSelect: function() {
1423                 network = bitcoinjs.bitcoin.networks.crown;
1424                 setHdCoin(72);
1425             },
1426         },
1427         {
1428             name: "DASH - Dash",
1429             segwitAvailable: false,
1430             onSelect: function() {
1431                 network = bitcoinjs.bitcoin.networks.dash;
1432                 setHdCoin(5);
1433             },
1434         },
1435         {
1436             name: "DASH - Dash Testnet",
1437             segwitAvailable: false,
1438             onSelect: function() {
1439                 network = bitcoinjs.bitcoin.networks.dashtn;
1440                 setHdCoin(1);
1441             },
1442         },
1443         {
1444             name: "DOGE - Dogecoin",
1445             segwitAvailable: false,
1446             onSelect: function() {
1447                 network = bitcoinjs.bitcoin.networks.dogecoin;
1448                 setHdCoin(3);
1449             },
1450         },
1451         {
1452             name: "ETH - Ethereum",
1453             segwitAvailable: false,
1454             onSelect: function() {
1455                 network = bitcoinjs.bitcoin.networks.bitcoin;
1456                 setHdCoin(60);
1457             },
1458         },
1459         {
1460             name: "FJC - Fujicoin",
1461             segwitAvailable: false,
1462             onSelect: function() {
1463                 network = bitcoinjs.bitcoin.networks.fujicoin;
1464                 setHdCoin(75);
1465             },
1466         },
1467         {
1468             name: "GAME - GameCredits",
1469             segwitAvailable: false,
1470             onSelect: function() {
1471                 network = bitcoinjs.bitcoin.networks.game;
1472                 setHdCoin(101);
1473             },
1474         },
1475         {
1476             name: "JBS - Jumbucks",
1477             segwitAvailable: false,
1478             onSelect: function() {
1479                 network = bitcoinjs.bitcoin.networks.jumbucks;
1480                 setHdCoin(26);
1481             },
1482         },
1483         {
1484             name: "LTC - Litecoin",
1485             segwitAvailable: true,
1486             onSelect: function() {
1487                 network = bitcoinjs.bitcoin.networks.litecoin;
1488                 setHdCoin(2);
1489                 DOM.litecoinLtubContainer.removeClass("hidden");
1490             },
1491         },
1492         {
1493             name: "MAZA - Maza",
1494             segwitAvailable: false,
1495             onSelect: function() {
1496                 network = bitcoinjs.bitcoin.networks.maza;
1497                 setHdCoin(13);
1498             },
1499         },
1500         {
1501             name: "MONA - Monacoin",
1502             segwitAvailable: true,
1503             onSelect: function() {
1504                 network = bitcoinjs.bitcoin.networks.monacoin,
1505                 setHdCoin(22);
1506             },
1507         },
1508         {
1509             name: "NMC - Namecoin",
1510             segwitAvailable: false,
1511             onSelect: function() {
1512                 network = bitcoinjs.bitcoin.networks.namecoin;
1513                 setHdCoin(7);
1514             },
1515         },
1516         {
1517             name: "PIVX - PIVX",
1518             segwitAvailable: false,
1519             onSelect: function() {
1520                 network = bitcoinjs.bitcoin.networks.pivx;
1521                 setHdCoin(119);
1522             },
1523         },
1524         {
1525             name: "PIVX - PIVX Testnet",
1526             segwitAvailable: false,
1527             onSelect: function() {
1528                 network = bitcoinjs.bitcoin.networks.pivxtestnet;
1529                 setHdCoin(1);
1530             },
1531         },
1532         {
1533             name: "PPC - Peercoin",
1534             segwitAvailable: false,
1535             onSelect: function() {
1536                 network = bitcoinjs.bitcoin.networks.peercoin;
1537                 setHdCoin(6);
1538             },
1539         },
1540         {
1541             name: "SDC - ShadowCash",
1542             segwitAvailable: false,
1543             onSelect: function() {
1544                 network = bitcoinjs.bitcoin.networks.shadow;
1545                 setHdCoin(35);
1546             },
1547         },
1548         {
1549             name: "SDC - ShadowCash Testnet",
1550             segwitAvailable: false,
1551             onSelect: function() {
1552                 network = bitcoinjs.bitcoin.networks.shadowtn;
1553                 setHdCoin(1);
1554             },
1555         },
1556         {
1557             name: "SLM - Slimcoin",
1558             segwitAvailable: false,
1559             onSelect: function() {
1560                 network = bitcoinjs.bitcoin.networks.slimcoin;
1561                 setHdCoin(63);
1562             },
1563         },
1564         {
1565             name: "SLM - Slimcoin Testnet",
1566             segwitAvailable: false,
1567             onSelect: function() {
1568                 network = bitcoinjs.bitcoin.networks.slimcointn;
1569                 setHdCoin(111);
1570             },
1571         },
1572         {
1573             name: "USNBT - NuBits",
1574             segwitAvailable: false,
1575             onSelect: function() {
1576                 network = bitcoinjs.bitcoin.networks.nubits;
1577                 setHdCoin(12);
1578             },
1579         },
1580         {
1581             name: "VIA - Viacoin",
1582             segwitAvailable: false,
1583             onSelect: function() {
1584                 network = bitcoinjs.bitcoin.networks.viacoin;
1585                 setHdCoin(14);
1586             },
1587         },
1588         {
1589             name: "VIA - Viacoin Testnet",
1590             segwitAvailable: false,
1591             onSelect: function() {
1592                 network = bitcoinjs.bitcoin.networks.viacointestnet;
1593                 setHdCoin(1);
1594             },
1595         },
1596         {
1597             name: "XMY - Myriadcoin",
1598             segwitAvailable: false,
1599             onSelect: function() {
1600                 network = bitcoinjs.bitcoin.networks.myriadcoin;
1601                 setHdCoin(90);
1602             },
1603         },
1604         {
1605             name: "XRP - Ripple",
1606             segwitAvailable: false,
1607             onSelect: function() {
1608                 network = bitcoinjs.bitcoin.networks.bitcoin;
1609                 setHdCoin(144);
1610             },
1611         }
1612     ]
1613
1614     var clients = [
1615         {
1616             name: "Bitcoin Core",
1617             onSelect: function() {
1618                 DOM.bip32path.val("m/0'/0'");
1619                 DOM.hardenedAddresses.prop('checked', true);
1620             },
1621         },
1622         {
1623             name: "blockchain.info",
1624             onSelect: function() {
1625                 DOM.bip32path.val("m/44'/0'/0'");
1626                 DOM.hardenedAddresses.prop('checked', false);
1627             },
1628         },
1629         {
1630             name: "MultiBit HD",
1631             onSelect: function() {
1632                 DOM.bip32path.val("m/0'/0");
1633                 DOM.hardenedAddresses.prop('checked', false);
1634             },
1635         }
1636     ]
1637
1638     init();
1639
1640 })();