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 = libs.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 entropyTypeAutoDetect = true;
  20     var entropyChangeTimeoutEvent = null;
  21     var phraseChangeTimeoutEvent = null;
  22     var seedChangedTimeoutEvent = null;
  23     var rootKeyChangedTimeoutEvent = null;
  24
  25     var generationProcesses = [];
  26
  27     var DOM = {};
  28     DOM.privacyScreenToggle = $(".privacy-screen-toggle");
  29     DOM.network = $(".network");
  30     DOM.bip32Client = $("#bip32-client");
  31     DOM.phraseNetwork = $("#network-phrase");
  32     DOM.useEntropy = $(".use-entropy");
  33     DOM.entropyContainer = $(".entropy-container");
  34     DOM.entropy = $(".entropy");
  35     DOM.entropyFiltered = DOM.entropyContainer.find(".filtered");
  36     DOM.entropyType = DOM.entropyContainer.find(".type");
  37     DOM.entropyTypeInputs = DOM.entropyContainer.find("input[name='entropy-type']");
  38     DOM.entropyCrackTime = DOM.entropyContainer.find(".crack-time");
  39     DOM.entropyEventCount = DOM.entropyContainer.find(".event-count");
  40     DOM.entropyBits = DOM.entropyContainer.find(".bits");
  41     DOM.entropyBitsPerEvent = DOM.entropyContainer.find(".bits-per-event");
  42     DOM.entropyWordCount = DOM.entropyContainer.find(".word-count");
  43     DOM.entropyBinary = DOM.entropyContainer.find(".binary");
  44     DOM.entropyWordIndexes = DOM.entropyContainer.find(".word-indexes");
  45     DOM.entropyChecksum = DOM.entropyContainer.find(".checksum");
  46     DOM.entropyMnemonicLength = DOM.entropyContainer.find(".mnemonic-length");
  47     DOM.entropyWeakEntropyOverrideWarning = DOM.entropyContainer.find(".weak-entropy-override-warning");
  48     DOM.entropyFilterWarning = DOM.entropyContainer.find(".filter-warning");
  49     DOM.phrase = $(".phrase");
  50     DOM.splitMnemonic = $(".splitMnemonic");
  51     DOM.showSplitMnemonic = $(".showSplitMnemonic");
  52     DOM.phraseSplit = $(".phraseSplit");
  53     DOM.phraseSplitWarn = $(".phraseSplitWarn");
  54     DOM.passphrase = $(".passphrase");
  55     DOM.generateContainer = $(".generate-container");
  56     DOM.generate = $(".generate");
  57     DOM.seed = $(".seed");
  58     DOM.rootKey = $(".root-key");
  59     DOM.litecoinLtubContainer = $(".litecoin-ltub-container");
  60     DOM.litecoinUseLtub = $(".litecoin-use-ltub");
  61     DOM.extendedPrivKey = $(".extended-priv-key");
  62     DOM.extendedPubKey = $(".extended-pub-key");
  63     DOM.bip32tab = $("#bip32-tab");
  64     DOM.bip44tab = $("#bip44-tab");
  65     DOM.bip49tab = $("#bip49-tab");
  66     DOM.bip84tab = $("#bip84-tab");
  67     DOM.bip141tab = $("#bip141-tab");
  68     DOM.bip32panel = $("#bip32");
  69     DOM.bip44panel = $("#bip44");
  70     DOM.bip49panel = $("#bip49");
  71     DOM.bip32path = $("#bip32-path");
  72     DOM.bip44path = $("#bip44-path");
  73     DOM.bip44purpose = $("#bip44 .purpose");
  74     DOM.bip44coin = $("#bip44 .coin");
  75     DOM.bip44account = $("#bip44 .account");
  76     DOM.bip44accountXprv = $("#bip44 .account-xprv");
  77     DOM.bip44accountXpub = $("#bip44 .account-xpub");
  78     DOM.bip44change = $("#bip44 .change");
  79     DOM.bip49unavailable = $("#bip49 .unavailable");
  80     DOM.bip49available = $("#bip49 .available");
  81     DOM.bip49path = $("#bip49-path");
  82     DOM.bip49purpose = $("#bip49 .purpose");
  83     DOM.bip49coin = $("#bip49 .coin");
  84     DOM.bip49account = $("#bip49 .account");
  85     DOM.bip49accountXprv = $("#bip49 .account-xprv");
  86     DOM.bip49accountXpub = $("#bip49 .account-xpub");
  87     DOM.bip49change = $("#bip49 .change");
  88     DOM.bip84unavailable = $("#bip84 .unavailable");
  89     DOM.bip84available = $("#bip84 .available");
  90     DOM.bip84path = $("#bip84-path");
  91     DOM.bip84purpose = $("#bip84 .purpose");
  92     DOM.bip84coin = $("#bip84 .coin");
  93     DOM.bip84account = $("#bip84 .account");
  94     DOM.bip84accountXprv = $("#bip84 .account-xprv");
  95     DOM.bip84accountXpub = $("#bip84 .account-xpub");
  96     DOM.bip84change = $("#bip84 .change");
  97     DOM.bip141unavailable = $("#bip141 .unavailable");
  98     DOM.bip141available = $("#bip141 .available");
  99     DOM.bip141path = $("#bip141-path");
 100     DOM.bip141semantics = $(".bip141-semantics");
 101     DOM.generatedStrength = $(".generate-container .strength");
 102     DOM.generatedStrengthWarning = $(".generate-container .warning");
 103     DOM.hardenedAddresses = $(".hardened-addresses");
 104     DOM.bitcoinCashAddressTypeContainer = $(".bch-addr-type-container");
 105     DOM.bitcoinCashAddressType = $("[name=bch-addr-type]")
 106     DOM.useBip38 = $(".use-bip38");
 107     DOM.bip38Password = $(".bip38-password");
 108     DOM.addresses = $(".addresses");
 109     DOM.csvTab = $("#csv-tab a");
 110     DOM.csv = $(".csv");
 111     DOM.rowsToAdd = $(".rows-to-add");
 112     DOM.more = $(".more");
 113     DOM.moreRowsStartIndex = $(".more-rows-start-index");
 114     DOM.feedback = $(".feedback");
 115     DOM.tab = $(".derivation-type a");
 116     DOM.indexToggle = $(".index-toggle");
 117     DOM.addressToggle = $(".address-toggle");
 118     DOM.publicKeyToggle = $(".public-key-toggle");
 119     DOM.privateKeyToggle = $(".private-key-toggle");
 120     DOM.languages = $(".languages a");
 121     DOM.qrContainer = $(".qr-container");
 122     DOM.qrHider = DOM.qrContainer.find(".qr-hider");
 123     DOM.qrImage = DOM.qrContainer.find(".qr-image");
 124     DOM.qrHint = DOM.qrContainer.find(".qr-hint");
 125     DOM.showQrEls = $("[data-show-qr]");
 126
 127     function init() {
 128         // Events
 129         DOM.privacyScreenToggle.on("change", privacyScreenToggled);
 130         DOM.generatedStrength.on("change", generatedStrengthChanged);
 131         DOM.network.on("change", networkChanged);
 132         DOM.bip32Client.on("change", bip32ClientChanged);
 133         DOM.useEntropy.on("change", setEntropyVisibility);
 134         DOM.entropy.on("input", delayedEntropyChanged);
 135         DOM.entropyMnemonicLength.on("change", entropyChanged);
 136         DOM.entropyTypeInputs.on("change", entropyTypeChanged);
 137         DOM.phrase.on("input", delayedPhraseChanged);
 138         DOM.showSplitMnemonic.on("change", toggleSplitMnemonic);
 139         DOM.passphrase.on("input", delayedPhraseChanged);
 140         DOM.generate.on("click", generateClicked);
 141         DOM.more.on("click", showMore);
 142         DOM.seed.on("input", delayedSeedChanged);
 143         DOM.rootKey.on("input", delayedRootKeyChanged);
 144         DOM.litecoinUseLtub.on("change", litecoinUseLtubChanged);
 145         DOM.bip32path.on("input", calcForDerivationPath);
 146         DOM.bip44account.on("input", calcForDerivationPath);
 147         DOM.bip44change.on("input", calcForDerivationPath);
 148         DOM.bip49account.on("input", calcForDerivationPath);
 149         DOM.bip49change.on("input", calcForDerivationPath);
 150         DOM.bip84account.on("input", calcForDerivationPath);
 151         DOM.bip84change.on("input", calcForDerivationPath);
 152         DOM.bip141path.on("input", calcForDerivationPath);
 153         DOM.bip141semantics.on("change", tabChanged);
 154         DOM.tab.on("shown.bs.tab", tabChanged);
 155         DOM.hardenedAddresses.on("change", calcForDerivationPath);
 156         DOM.useBip38.on("change", calcForDerivationPath);
 157         DOM.bip38Password.on("change", calcForDerivationPath);
 158         DOM.indexToggle.on("click", toggleIndexes);
 159         DOM.addressToggle.on("click", toggleAddresses);
 160         DOM.publicKeyToggle.on("click", togglePublicKeys);
 161         DOM.privateKeyToggle.on("click", togglePrivateKeys);
 162         DOM.csvTab.on("click", updateCsv);
 163         DOM.languages.on("click", languageChanged);
 164         DOM.bitcoinCashAddressType.on("change", bitcoinCashAddressTypeChange);
 165         setQrEvents(DOM.showQrEls);
 166         disableForms();
 167         hidePending();
 168         hideValidationError();
 169         populateNetworkSelect();
 170         populateClientSelect();
 171     }
 172
 173     // Event handlers
 174
 175     function generatedStrengthChanged() {
 176         var strength = parseInt(DOM.generatedStrength.val());
 177         if (strength < 12) {
 178             DOM.generatedStrengthWarning.removeClass("hidden");
 179         }
 180         else {
 181             DOM.generatedStrengthWarning.addClass("hidden");
 182         }
 183     }
 184
 185     function networkChanged(e) {
 186         clearDerivedKeys();
 187         clearAddressesList();
 188         DOM.litecoinLtubContainer.addClass("hidden");
 189         DOM.bitcoinCashAddressTypeContainer.addClass("hidden");
 190         var networkIndex = e.target.value;
 191         var network = networks[networkIndex];
 192         network.onSelect();
 193         adjustNetworkForSegwit();
 194         if (seed != null) {
 195             phraseChanged();
 196         }
 197         else {
 198             rootKeyChanged();
 199         }
 200     }
 201
 202     function bip32ClientChanged(e) {
 203         var clientIndex = DOM.bip32Client.val();
 204         if (clientIndex == "custom") {
 205             DOM.bip32path.prop("readonly", false);
 206         }
 207         else {
 208             DOM.bip32path.prop("readonly", true);
 209             clients[clientIndex].onSelect();
 210             if (seed != null) {
 211                 phraseChanged();
 212             }
 213             else {
 214                 rootKeyChanged();
 215             }
 216         }
 217     }
 218
 219     function setEntropyVisibility() {
 220         if (isUsingOwnEntropy()) {
 221             DOM.entropyContainer.removeClass("hidden");
 222             DOM.generateContainer.addClass("hidden");
 223             DOM.phrase.prop("readonly", true);
 224             DOM.entropy.focus();
 225             entropyChanged();
 226         }
 227         else {
 228             DOM.entropyContainer.addClass("hidden");
 229             DOM.generateContainer.removeClass("hidden");
 230             DOM.phrase.prop("readonly", false);
 231             hidePending();
 232         }
 233     }
 234
 235     function delayedPhraseChanged() {
 236         hideValidationError();
 237         seed = null;
 238         bip32RootKey = null;
 239         bip32ExtendedKey = null;
 240         clearAddressesList();
 241         showPending();
 242         if (phraseChangeTimeoutEvent != null) {
 243             clearTimeout(phraseChangeTimeoutEvent);
 244         }
 245         phraseChangeTimeoutEvent = setTimeout(function() {
 246             phraseChanged();
 247             var entropy = mnemonic.toRawEntropyHex(DOM.phrase.val());
 248             if (entropy !== null) {
 249                 DOM.entropyMnemonicLength.val("raw");
 250                 DOM.entropy.val(entropy);
 251                 DOM.entropyTypeInputs.filter("[value='hexadecimal']").prop("checked", true);
 252                 entropyTypeAutoDetect = false;
 253             }
 254         }, 400);
 255     }
 256
 257     function phraseChanged() {
 258         showPending();
 259         setMnemonicLanguage();
 260         // Get the mnemonic phrase
 261         var phrase = DOM.phrase.val();
 262         var errorText = findPhraseErrors(phrase);
 263         if (errorText) {
 264             showValidationError(errorText);
 265             return;
 266         }
 267         // Calculate and display
 268         var passphrase = DOM.passphrase.val();
 269         calcBip32RootKeyFromSeed(phrase, passphrase);
 270         calcForDerivationPath();
 271         // Show the word indexes
 272         showWordIndexes();
 273         writeSplitPhrase(phrase);
 274     }
 275
 276     function tabChanged() {
 277         showPending();
 278         adjustNetworkForSegwit();
 279         var phrase = DOM.phrase.val();
 280         if (phrase != "") {
 281             // Calculate and display for mnemonic
 282             var errorText = findPhraseErrors(phrase);
 283             if (errorText) {
 284                 showValidationError(errorText);
 285                 return;
 286             }
 287             // Calculate and display
 288             var passphrase = DOM.passphrase.val();
 289             calcBip32RootKeyFromSeed(phrase, passphrase);
 290         }
 291         else {
 292             // Calculate and display for root key
 293             var rootKeyBase58 = DOM.rootKey.val();
 294             var errorText = validateRootKey(rootKeyBase58);
 295             if (errorText) {
 296                 showValidationError(errorText);
 297                 return;
 298             }
 299             // Calculate and display
 300             calcBip32RootKeyFromBase58(rootKeyBase58);
 301         }
 302         calcForDerivationPath();
 303     }
 304
 305     function delayedEntropyChanged() {
 306         hideValidationError();
 307         showPending();
 308         if (entropyChangeTimeoutEvent != null) {
 309             clearTimeout(entropyChangeTimeoutEvent);
 310         }
 311         entropyChangeTimeoutEvent = setTimeout(entropyChanged, 400);
 312     }
 313
 314     function entropyChanged() {
 315         // If blank entropy, clear mnemonic, addresses, errors
 316         if (DOM.entropy.val().trim().length == 0) {
 317             clearDisplay();
 318             clearEntropyFeedback();
 319             DOM.phrase.val("");
 320             DOM.phraseSplit.val("");
 321             showValidationError("Blank entropy");
 322             return;
 323         }
 324         // Get the current phrase to detect changes
 325         var phrase = DOM.phrase.val();
 326         // Set the phrase from the entropy
 327         setMnemonicFromEntropy();
 328         // Recalc addresses if the phrase has changed
 329         var newPhrase = DOM.phrase.val();
 330         if (newPhrase != phrase) {
 331             if (newPhrase.length == 0) {
 332                 clearDisplay();
 333             }
 334             else {
 335                 phraseChanged();
 336             }
 337         }
 338         else {
 339             hidePending();
 340         }
 341     }
 342
 343     function entropyTypeChanged() {
 344         entropyTypeAutoDetect = false;
 345         entropyChanged();
 346     }
 347
 348     function delayedSeedChanged() {
 349         // Warn if there is an existing mnemonic or passphrase.
 350         if (DOM.phrase.val().length > 0 || DOM.passphrase.val().length > 0) {
 351             if (!confirm("This will clear existing mnemonic and passphrase")) {
 352                 DOM.seed.val(seed);
 353                 return
 354             }
 355         }
 356         hideValidationError();
 357         showPending();
 358         // Clear existing mnemonic and passphrase
 359         DOM.phrase.val("");
 360         DOM.phraseSplit.val("");
 361         DOM.passphrase.val("");
 362         DOM.rootKey.val("");
 363         clearAddressesList();
 364         clearDerivedKeys();
 365         seed = null;
 366         if (seedChangedTimeoutEvent != null) {
 367             clearTimeout(seedChangedTimeoutEvent);
 368         }
 369         seedChangedTimeoutEvent = setTimeout(seedChanged, 400);
 370     }
 371
 372     function delayedRootKeyChanged() {
 373         // Warn if there is an existing mnemonic or passphrase.
 374         if (DOM.phrase.val().length > 0 || DOM.passphrase.val().length > 0) {
 375             if (!confirm("This will clear existing mnemonic and passphrase")) {
 376                 DOM.rootKey.val(bip32RootKey);
 377                 return
 378             }
 379         }
 380         hideValidationError();
 381         showPending();
 382         // Clear existing mnemonic and passphrase
 383         DOM.phrase.val("");
 384         DOM.phraseSplit.val("");
 385         DOM.passphrase.val("");
 386         seed = null;
 387         if (rootKeyChangedTimeoutEvent != null) {
 388             clearTimeout(rootKeyChangedTimeoutEvent);
 389         }
 390         rootKeyChangedTimeoutEvent = setTimeout(rootKeyChanged, 400);
 391     }
 392
 393     function seedChanged() {
 394         showPending();
 395         hideValidationError();
 396         seed = DOM.seed.val();
 397         bip32RootKey = libs.bitcoin.HDNode.fromSeedHex(seed, network);
 398         var rootKeyBase58 = bip32RootKey.toBase58();
 399         DOM.rootKey.val(rootKeyBase58);
 400         var errorText = validateRootKey(rootKeyBase58);
 401         if (errorText) {
 402             showValidationError(errorText);
 403             return;
 404         }
 405         // Calculate and display
 406         calcForDerivationPath();
 407     }
 408
 409     function rootKeyChanged() {
 410         showPending();
 411         hideValidationError();
 412         var rootKeyBase58 = DOM.rootKey.val();
 413         var errorText = validateRootKey(rootKeyBase58);
 414         if (errorText) {
 415             showValidationError(errorText);
 416             return;
 417         }
 418         // Calculate and display
 419         calcBip32RootKeyFromBase58(rootKeyBase58);
 420         calcForDerivationPath();
 421     }
 422
 423     function litecoinUseLtubChanged() {
 424         litecoinUseLtub = DOM.litecoinUseLtub.prop("checked");
 425         if (litecoinUseLtub) {
 426             network = libs.bitcoin.networks.litecoin;
 427         }
 428         else {
 429             network = libs.bitcoin.networks.litecoinXprv;
 430         }
 431         phraseChanged();
 432     }
 433
 434     function toggleSplitMnemonic() {
 435         if (DOM.showSplitMnemonic.prop("checked")) {
 436             DOM.splitMnemonic.removeClass("hidden");
 437         }
 438         else {
 439             DOM.splitMnemonic.addClass("hidden");
 440         }
 441     }
 442
 443     function calcForDerivationPath() {
 444         clearDerivedKeys();
 445         clearAddressesList();
 446         showPending();
 447         // Don't show segwit if it's selected but network doesn't support it
 448         if (segwitSelected() && !networkHasSegwit()) {
 449             showSegwitUnavailable();
 450             hidePending();
 451             return;
 452         }
 453         showSegwitAvailable();
 454         // Get the derivation path
 455         var derivationPath = getDerivationPath();
 456         var errorText = findDerivationPathErrors(derivationPath);
 457         if (errorText) {
 458             showValidationError(errorText);
 459             return;
 460         }
 461         bip32ExtendedKey = calcBip32ExtendedKey(derivationPath);
 462         if (bip44TabSelected()) {
 463             displayBip44Info();
 464         }
 465         else if (bip49TabSelected()) {
 466             displayBip49Info();
 467         }
 468         else if (bip84TabSelected()) {
 469             displayBip84Info();
 470         }
 471         displayBip32Info();
 472     }
 473
 474     function generateClicked() {
 475         if (isUsingOwnEntropy()) {
 476             return;
 477         }
 478         clearDisplay();
 479         showPending();
 480         setTimeout(function() {
 481             setMnemonicLanguage();
 482             var phrase = generateRandomPhrase();
 483             if (!phrase) {
 484                 return;
 485             }
 486             phraseChanged();
 487         }, 50);
 488     }
 489
 490     function languageChanged() {
 491         setTimeout(function() {
 492             setMnemonicLanguage();
 493             if (DOM.phrase.val().length > 0) {
 494                 var newPhrase = convertPhraseToNewLanguage();
 495                 DOM.phrase.val(newPhrase);
 496                 phraseChanged();
 497             }
 498             else {
 499                 DOM.generate.trigger("click");
 500             }
 501         }, 50);
 502     }
 503
 504     function bitcoinCashAddressTypeChange() {
 505         phraseChanged();
 506     }
 507
 508     function toggleIndexes() {
 509         showIndex = !showIndex;
 510         $("td.index span").toggleClass("invisible");
 511     }
 512
 513     function toggleAddresses() {
 514         showAddress = !showAddress;
 515         $("td.address span").toggleClass("invisible");
 516     }
 517
 518     function togglePublicKeys() {
 519         showPubKey = !showPubKey;
 520         $("td.pubkey span").toggleClass("invisible");
 521     }
 522
 523     function togglePrivateKeys() {
 524         showPrivKey = !showPrivKey;
 525         $("td.privkey span").toggleClass("invisible");
 526     }
 527
 528     function privacyScreenToggled() {
 529         // private-data contains elements added to DOM at runtime
 530         // so catch all by adding visual privacy class to the root of the DOM
 531         if (DOM.privacyScreenToggle.prop("checked")) {
 532             $("body").addClass("visual-privacy");
 533         }
 534         else {
 535             $("body").removeClass("visual-privacy");
 536         }
 537     }
 538
 539     // Private methods
 540
 541     function generateRandomPhrase() {
 542         if (!hasStrongRandom()) {
 543             var errorText = "This browser does not support strong randomness";
 544             showValidationError(errorText);
 545             return;
 546         }
 547         // get the amount of entropy to use
 548         var numWords = parseInt(DOM.generatedStrength.val());
 549         var strength = numWords / 3 * 32;
 550         var buffer = new Uint8Array(strength / 8);
 551         // create secure entropy
 552         var data = crypto.getRandomValues(buffer);
 553         // show the words
 554         var words = mnemonic.toMnemonic(data);
 555         DOM.phrase.val(words);
 556         // show the entropy
 557         var entropyHex = uint8ArrayToHex(data);
 558         DOM.entropy.val(entropyHex);
 559         // ensure entropy fields are consistent with what is being displayed
 560         DOM.entropyMnemonicLength.val("raw");
 561         return words;
 562     }
 563
 564     function calcBip32RootKeyFromSeed(phrase, passphrase) {
 565         seed = mnemonic.toSeed(phrase, passphrase);
 566         bip32RootKey = libs.bitcoin.HDNode.fromSeedHex(seed, network);
 567         if(isGRS())
 568             bip32RootKey = libs.groestlcoinjs.HDNode.fromSeedHex(seed, network);
 569
 570     }
 571
 572     function calcBip32RootKeyFromBase58(rootKeyBase58) {
 573         if(isGRS()) {
 574             calcBip32RootKeyFromBase58GRS(rootKeyBase58);
 575             return;
 576         }
 577         // try parsing with various segwit network params since this extended
 578         // key may be from any one of them.
 579         if (networkHasSegwit()) {
 580             var n = network;
 581             if ("baseNetwork" in n) {
 582                 n = libs.bitcoin.networks[n.baseNetwork];
 583             }
 584             // try parsing using base network params
 585             try {
 586                 bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n);
 587                 return;
 588             }
 589             catch (e) {}
 590             // try parsing using p2wpkh params
 591             if ("p2wpkh" in n) {
 592                 try {
 593                     bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
 594                     return;
 595                 }
 596                 catch (e) {}
 597             }
 598             // try parsing using p2wpkh-in-p2sh network params
 599             if ("p2wpkhInP2sh" in n) {
 600                 try {
 601                     bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
 602                     return;
 603                 }
 604                 catch (e) {}
 605             }
 606             // try parsing using p2wsh network params
 607             if ("p2wsh" in n) {
 608                 try {
 609                     bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wsh);
 610                     return;
 611                 }
 612                 catch (e) {}
 613             }
 614             // try parsing using p2wsh-in-p2sh network params
 615             if ("p2wshInP2sh" in n) {
 616                 try {
 617                     bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wshInP2sh);
 618                     return;
 619                 }
 620                 catch (e) {}
 621             }
 622         }
 623         // try the network params as currently specified
 624         bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, network);
 625     }
 626
 627     function calcBip32RootKeyFromBase58GRS(rootKeyBase58) {
 628         // try parsing with various segwit network params since this extended
 629         // key may be from any one of them.
 630         if (networkHasSegwit()) {
 631             var n = network;
 632             if ("baseNetwork" in n) {
 633                 n = libs.bitcoin.networks[n.baseNetwork];
 634             }
 635             // try parsing using base network params
 636             try {
 637                 bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n);
 638                 return;
 639             }
 640             catch (e) {}
 641             // try parsing using p2wpkh params
 642             if ("p2wpkh" in n) {
 643                 try {
 644                     bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
 645                     return;
 646                 }
 647                 catch (e) {}
 648             }
 649             // try parsing using p2wpkh-in-p2sh network params
 650             if ("p2wpkhInP2sh" in n) {
 651                 try {
 652                     bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
 653                     return;
 654                 }
 655                 catch (e) {}
 656             }
 657         }
 658         // try the network params as currently specified
 659         bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, network);
 660     }
 661
 662     function calcBip32ExtendedKey(path) {
 663         // Check there's a root key to derive from
 664         if (!bip32RootKey) {
 665             return bip32RootKey;
 666         }
 667         var extendedKey = bip32RootKey;
 668         // Derive the key from the path
 669         var pathBits = path.split("/");
 670         for (var i=0; i<pathBits.length; i++) {
 671             var bit = pathBits[i];
 672             var index = parseInt(bit);
 673             if (isNaN(index)) {
 674                 continue;
 675             }
 676             var hardened = bit[bit.length-1] == "'";
 677             var isPriv = !(extendedKey.isNeutered());
 678             var invalidDerivationPath = hardened && !isPriv;
 679             if (invalidDerivationPath) {
 680                 extendedKey = null;
 681             }
 682             else if (hardened) {
 683                 extendedKey = extendedKey.deriveHardened(index);
 684             }
 685             else {
 686                 extendedKey = extendedKey.derive(index);
 687             }
 688         }
 689         return extendedKey;
 690     }
 691
 692     function showValidationError(errorText) {
 693         DOM.feedback
 694             .text(errorText)
 695             .show();
 696     }
 697
 698     function hideValidationError() {
 699         DOM.feedback
 700             .text("")
 701             .hide();
 702     }
 703
 704     function findPhraseErrors(phrase) {
 705         // Preprocess the words
 706         phrase = mnemonic.normalizeString(phrase);
 707         var words = phraseToWordArray(phrase);
 708         // Detect blank phrase
 709         if (words.length == 0) {
 710             return "Blank mnemonic";
 711         }
 712         // Check each word
 713         for (var i=0; i<words.length; i++) {
 714             var word = words[i];
 715             var language = getLanguage();
 716             if (WORDLISTS[language].indexOf(word) == -1) {
 717                 console.log("Finding closest match to " + word);
 718                 var nearestWord = findNearestWord(word);
 719                 return word + " not in wordlist, did you mean " + nearestWord + "?";
 720             }
 721         }
 722         // Check the words are valid
 723         var properPhrase = wordArrayToPhrase(words);
 724         var isValid = mnemonic.check(properPhrase);
 725         if (!isValid) {
 726             return "Invalid mnemonic";
 727         }
 728         return false;
 729     }
 730
 731     function validateRootKey(rootKeyBase58) {
 732         if(isGRS())
 733             return validateRootKeyGRS(rootKeyBase58);
 734
 735         // try various segwit network params since this extended key may be from
 736         // any one of them.
 737         if (networkHasSegwit()) {
 738             var n = network;
 739             if ("baseNetwork" in n) {
 740                 n = libs.bitcoin.networks[n.baseNetwork];
 741             }
 742             // try parsing using base network params
 743             try {
 744                 libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n);
 745                 return "";
 746             }
 747             catch (e) {}
 748             // try parsing using p2wpkh params
 749             if ("p2wpkh" in n) {
 750                 try {
 751                     libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
 752                     return "";
 753                 }
 754                 catch (e) {}
 755             }
 756             // try parsing using p2wpkh-in-p2sh network params
 757             if ("p2wpkhInP2sh" in n) {
 758                 try {
 759                     libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
 760                     return "";
 761                 }
 762                 catch (e) {}
 763             }
 764             // try parsing using p2wsh network params
 765             if ("p2wsh" in n) {
 766                 try {
 767                     libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wsh);
 768                     return "";
 769                 }
 770                 catch (e) {}
 771             }
 772             // try parsing using p2wsh-in-p2sh network params
 773             if ("p2wshInP2sh" in n) {
 774                 try {
 775                     libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wshInP2sh);
 776                     return "";
 777                 }
 778                 catch (e) {}
 779             }
 780         }
 781         // try the network params as currently specified
 782         try {
 783             libs.bitcoin.HDNode.fromBase58(rootKeyBase58, network);
 784         }
 785         catch (e) {
 786             return "Invalid root key";
 787         }
 788         return "";
 789     }
 790
 791     function validateRootKeyGRS(rootKeyBase58) {
 792         // try various segwit network params since this extended key may be from
 793         // any one of them.
 794         if (networkHasSegwit()) {
 795             var n = network;
 796             if ("baseNetwork" in n) {
 797                 n = libs.bitcoin.networks[n.baseNetwork];
 798             }
 799             // try parsing using base network params
 800             try {
 801                 libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n);
 802                 return "";
 803             }
 804             catch (e) {}
 805             // try parsing using p2wpkh params
 806             if ("p2wpkh" in n) {
 807                 try {
 808                     libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
 809                     return "";
 810                 }
 811                 catch (e) {}
 812             }
 813             // try parsing using p2wpkh-in-p2sh network params
 814             if ("p2wpkhInP2sh" in n) {
 815                 try {
 816                     libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
 817                     return "";
 818                 }
 819                 catch (e) {}
 820             }
 821         }
 822         // try the network params as currently specified
 823         try {
 824             libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, network);
 825         }
 826         catch (e) {
 827             return "Invalid root key";
 828         }
 829         return "";
 830     }
 831
 832     function getDerivationPath() {
 833         if (bip44TabSelected()) {
 834             var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
 835             var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
 836             var account = parseIntNoNaN(DOM.bip44account.val(), 0);
 837             var change = parseIntNoNaN(DOM.bip44change.val(), 0);
 838             var path = "m/";
 839             path += purpose + "'/";
 840             path += coin + "'/";
 841             path += account + "'/";
 842             path += change;
 843             DOM.bip44path.val(path);
 844             var derivationPath = DOM.bip44path.val();
 845             console.log("Using derivation path from BIP44 tab: " + derivationPath);
 846             return derivationPath;
 847         }
 848         else if (bip49TabSelected()) {
 849             var purpose = parseIntNoNaN(DOM.bip49purpose.val(), 49);
 850             var coin = parseIntNoNaN(DOM.bip49coin.val(), 0);
 851             var account = parseIntNoNaN(DOM.bip49account.val(), 0);
 852             var change = parseIntNoNaN(DOM.bip49change.val(), 0);
 853             var path = "m/";
 854             path += purpose + "'/";
 855             path += coin + "'/";
 856             path += account + "'/";
 857             path += change;
 858             DOM.bip49path.val(path);
 859             var derivationPath = DOM.bip49path.val();
 860             console.log("Using derivation path from BIP49 tab: " + derivationPath);
 861             return derivationPath;
 862         }
 863         else if (bip84TabSelected()) {
 864             var purpose = parseIntNoNaN(DOM.bip84purpose.val(), 84);
 865             var coin = parseIntNoNaN(DOM.bip84coin.val(), 0);
 866             var account = parseIntNoNaN(DOM.bip84account.val(), 0);
 867             var change = parseIntNoNaN(DOM.bip84change.val(), 0);
 868             var path = "m/";
 869             path += purpose + "'/";
 870             path += coin + "'/";
 871             path += account + "'/";
 872             path += change;
 873             DOM.bip84path.val(path);
 874             var derivationPath = DOM.bip84path.val();
 875             console.log("Using derivation path from BIP84 tab: " + derivationPath);
 876             return derivationPath;
 877         }
 878         else if (bip32TabSelected()) {
 879             var derivationPath = DOM.bip32path.val();
 880             console.log("Using derivation path from BIP32 tab: " + derivationPath);
 881             return derivationPath;
 882         }
 883         else if (bip141TabSelected()) {
 884             var derivationPath = DOM.bip141path.val();
 885             console.log("Using derivation path from BIP141 tab: " + derivationPath);
 886             return derivationPath;
 887         }
 888         else {
 889             console.log("Unknown derivation path");
 890         }
 891     }
 892
 893     function findDerivationPathErrors(path) {
 894         // TODO is not perfect but is better than nothing
 895         // Inspired by
 896         // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#test-vectors
 897         // and
 898         // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#extended-keys
 899         var maxDepth = 255; // TODO verify this!!
 900         var maxIndexValue = Math.pow(2, 31); // TODO verify this!!
 901         if (path[0] != "m") {
 902             return "First character must be 'm'";
 903         }
 904         if (path.length > 1) {
 905             if (path[1] != "/") {
 906                 return "Separator must be '/'";
 907             }
 908             var indexes = path.split("/");
 909             if (indexes.length > maxDepth) {
 910                 return "Derivation depth is " + indexes.length + ", must be less than " + maxDepth;
 911             }
 912             for (var depth = 1; depth<indexes.length; depth++) {
 913                 var index = indexes[depth];
 914                 var invalidChars = index.replace(/^[0-9]+'?$/g, "")
 915                 if (invalidChars.length > 0) {
 916                     return "Invalid characters " + invalidChars + " found at depth " + depth;
 917                 }
 918                 var indexValue = parseInt(index.replace("'", ""));
 919                 if (isNaN(depth)) {
 920                     return "Invalid number at depth " + depth;
 921                 }
 922                 if (indexValue > maxIndexValue) {
 923                     return "Value of " + indexValue + " at depth " + depth + " must be less than " + maxIndexValue;
 924                 }
 925             }
 926         }
 927         // Check root key exists or else derivation path is useless!
 928         if (!bip32RootKey) {
 929             return "No root key";
 930         }
 931         // Check no hardened derivation path when using xpub keys
 932         var hardenedPath = path.indexOf("'") > -1;
 933         var hardenedAddresses = bip32TabSelected() && DOM.hardenedAddresses.prop("checked");
 934         var hardened = hardenedPath || hardenedAddresses;
 935         var isXpubkey = bip32RootKey.isNeutered();
 936         if (hardened && isXpubkey) {
 937             return "Hardened derivation path is invalid with xpub key";
 938         }
 939         return false;
 940     }
 941
 942     function isGRS() {
 943         return networks[DOM.network.val()].name == "GRS - Groestlcoin" || networks[DOM.network.val()].name == "GRS - Groestlcoin Testnet";
 944     }
 945
 946     function isELA() {
 947         return networks[DOM.network.val()].name == "ELA - Elastos"
 948     }
 949
 950     function displayBip44Info() {
 951         // Get the derivation path for the account
 952         var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
 953         var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
 954         var account = parseIntNoNaN(DOM.bip44account.val(), 0);
 955         var path = "m/";
 956         path += purpose + "'/";
 957         path += coin + "'/";
 958         path += account + "'/";
 959         // Calculate the account extended keys
 960         var accountExtendedKey = calcBip32ExtendedKey(path);
 961         var accountXprv = accountExtendedKey.toBase58();
 962         var accountXpub = accountExtendedKey.neutered().toBase58();
 963
 964         // Display the extended keys
 965         DOM.bip44accountXprv.val(accountXprv);
 966         DOM.bip44accountXpub.val(accountXpub);
 967
 968         if (isELA()) {
 969             displayBip44InfoForELA();
 970         }
 971     }
 972
 973     function displayBip49Info() {
 974         // Get the derivation path for the account
 975         var purpose = parseIntNoNaN(DOM.bip49purpose.val(), 49);
 976         var coin = parseIntNoNaN(DOM.bip49coin.val(), 0);
 977         var account = parseIntNoNaN(DOM.bip49account.val(), 0);
 978         var path = "m/";
 979         path += purpose + "'/";
 980         path += coin + "'/";
 981         path += account + "'/";
 982         // Calculate the account extended keys
 983         var accountExtendedKey = calcBip32ExtendedKey(path);
 984         var accountXprv = accountExtendedKey.toBase58();
 985         var accountXpub = accountExtendedKey.neutered().toBase58();
 986         // Display the extended keys
 987         DOM.bip49accountXprv.val(accountXprv);
 988         DOM.bip49accountXpub.val(accountXpub);
 989     }
 990
 991     function displayBip84Info() {
 992         // Get the derivation path for the account
 993         var purpose = parseIntNoNaN(DOM.bip84purpose.val(), 84);
 994         var coin = parseIntNoNaN(DOM.bip84coin.val(), 0);
 995         var account = parseIntNoNaN(DOM.bip84account.val(), 0);
 996         var path = "m/";
 997         path += purpose + "'/";
 998         path += coin + "'/";
 999         path += account + "'/";
1000         // Calculate the account extended keys
1001         var accountExtendedKey = calcBip32ExtendedKey(path);
1002         var accountXprv = accountExtendedKey.toBase58();
1003         var accountXpub = accountExtendedKey.neutered().toBase58();
1004         // Display the extended keys
1005         DOM.bip84accountXprv.val(accountXprv);
1006         DOM.bip84accountXpub.val(accountXpub);
1007     }
1008
1009     function displayBip32Info() {
1010         // Display the key
1011         DOM.seed.val(seed);
1012         var rootKey = bip32RootKey.toBase58();
1013         DOM.rootKey.val(rootKey);
1014         var xprvkeyB58 = "NA";
1015         if (!bip32ExtendedKey.isNeutered()) {
1016             xprvkeyB58 = bip32ExtendedKey.toBase58();
1017         }
1018         var extendedPrivKey = xprvkeyB58;
1019         DOM.extendedPrivKey.val(extendedPrivKey);
1020         var extendedPubKey = bip32ExtendedKey.neutered().toBase58();
1021         DOM.extendedPubKey.val(extendedPubKey);
1022         // Display the addresses and privkeys
1023         clearAddressesList();
1024         var initialAddressCount = parseInt(DOM.rowsToAdd.val());
1025         displayAddresses(0, initialAddressCount);
1026
1027         if (isELA()) {
1028             displayBip32InfoForELA();
1029         }
1030     }
1031
1032     function displayAddresses(start, total) {
1033         generationProcesses.push(new (function() {
1034
1035             var rows = [];
1036
1037             this.stop = function() {
1038                 for (var i=0; i<rows.length; i++) {
1039                     rows[i].shouldGenerate = false;
1040                 }
1041                 hidePending();
1042             }
1043
1044             for (var i=0; i<total; i++) {
1045                 var index = i + start;
1046                 var isLast = i == total - 1;
1047                 rows.push(new TableRow(index, isLast));
1048             }
1049
1050         })());
1051     }
1052
1053     function segwitSelected() {
1054         return bip49TabSelected() || bip84TabSelected() || bip141TabSelected();
1055     }
1056
1057     function p2wpkhSelected() {
1058         return bip84TabSelected() ||
1059                 bip141TabSelected() && DOM.bip141semantics.val() == "p2wpkh";
1060     }
1061
1062     function p2wpkhInP2shSelected() {
1063         return bip49TabSelected() ||
1064             (bip141TabSelected() && DOM.bip141semantics.val() == "p2wpkh-p2sh");
1065     }
1066
1067     function p2wshSelected() {
1068         return bip141TabSelected() && DOM.bip141semantics.val() == "p2wsh";
1069     }
1070
1071     function p2wshInP2shSelected() {
1072         return (bip141TabSelected() && DOM.bip141semantics.val() == "p2wsh-p2sh");
1073     }
1074
1075     function TableRow(index, isLast) {
1076
1077         var self = this;
1078         this.shouldGenerate = true;
1079         var useHardenedAddresses = DOM.hardenedAddresses.prop("checked");
1080         var useBip38 = DOM.useBip38.prop("checked");
1081         var bip38password = DOM.bip38Password.val();
1082         var isSegwit = segwitSelected();
1083         var segwitAvailable = networkHasSegwit();
1084         var isP2wpkh = p2wpkhSelected();
1085         var isP2wpkhInP2sh = p2wpkhInP2shSelected();
1086         var isP2wsh = p2wshSelected();
1087         var isP2wshInP2sh = p2wshInP2shSelected();
1088
1089         function init() {
1090             calculateValues();
1091         }
1092
1093         function calculateValues() {
1094             setTimeout(function() {
1095                 if (!self.shouldGenerate) {
1096                     return;
1097                 }
1098                 // derive HDkey for this row of the table
1099                 var key = "NA";
1100                 if (useHardenedAddresses) {
1101                     key = bip32ExtendedKey.deriveHardened(index);
1102                 }
1103                 else {
1104                     key = bip32ExtendedKey.derive(index);
1105                 }
1106                 // bip38 requires uncompressed keys
1107                 // see https://github.com/iancoleman/bip39/issues/140#issuecomment-352164035
1108                 var keyPair = key.keyPair;
1109                 var useUncompressed = useBip38;
1110                 if (useUncompressed) {
1111                     keyPair = new libs.bitcoin.ECPair(keyPair.d, null, { network: network, compressed: false });
1112                     if(isGRS())
1113                         keyPair = new libs.groestlcoinjs.ECPair(keyPair.d, null, { network: network, compressed: false });
1114
1115                 }
1116                 // get address
1117                 var address = keyPair.getAddress().toString();
1118                 // get privkey
1119                 var hasPrivkey = !key.isNeutered();
1120                 var privkey = "NA";
1121                 if (hasPrivkey) {
1122                     privkey = keyPair.toWIF();
1123                     // BIP38 encode private key if required
1124                     if (useBip38) {
1125                         if(isGRS())
1126                             privkey = libs.groestlcoinjsBip38.encrypt(keyPair.d.toBuffer(), false, bip38password, function(p) {
1127                                 console.log("Progressed " + p.percent.toFixed(1) + "% for index " + index);
1128                             }, null, networks[DOM.network.val()].name.includes("Testnet"));
1129                         else
1130                             privkey = libs.bip38.encrypt(keyPair.d.toBuffer(), false, bip38password, function(p) {
1131                                 console.log("Progressed " + p.percent.toFixed(1) + "% for index " + index);
1132                             });
1133                     }
1134                 }
1135                 // get pubkey
1136                 var pubkey = keyPair.getPublicKeyBuffer().toString('hex');
1137                 var indexText = getDerivationPath() + "/" + index;
1138                 if (useHardenedAddresses) {
1139                     indexText = indexText + "'";
1140                 }
1141                 // Ethereum values are different
1142                 if (networkIsEthereum()) {
1143                     var pubkeyBuffer = keyPair.getPublicKeyBuffer();
1144                     var ethPubkey = libs.ethUtil.importPublic(pubkeyBuffer);
1145                     var addressBuffer = libs.ethUtil.publicToAddress(ethPubkey);
1146                     var hexAddress = addressBuffer.toString('hex');
1147                     var checksumAddress = libs.ethUtil.toChecksumAddress(hexAddress);
1148                     address = libs.ethUtil.addHexPrefix(checksumAddress);
1149                     pubkey = libs.ethUtil.addHexPrefix(pubkey);
1150                     if (hasPrivkey) {
1151                         privkey = libs.ethUtil.bufferToHex(keyPair.d.toBuffer());
1152                     }
1153                 }
1154                 //TRX is different
1155                 if (networks[DOM.network.val()].name == "TRX - Tron") {
1156                     keyPair = new libs.bitcoin.ECPair(keyPair.d, null, { network: network, compressed: false });
1157                     var pubkeyBuffer = keyPair.getPublicKeyBuffer();
1158                     var ethPubkey = libs.ethUtil.importPublic(pubkeyBuffer);
1159                     var addressBuffer = libs.ethUtil.publicToAddress(ethPubkey);
1160                     address = libs.bitcoin.address.toBase58Check(addressBuffer, 0x41);
1161                     if (hasPrivkey) {
1162                         privkey = keyPair.d.toBuffer().toString('hex');
1163                     }
1164                 }
1165
1166                 // RSK values are different
1167                 if (networkIsRsk()) {
1168                     var pubkeyBuffer = keyPair.getPublicKeyBuffer();
1169                     var ethPubkey = libs.ethUtil.importPublic(pubkeyBuffer);
1170                     var addressBuffer = libs.ethUtil.publicToAddress(ethPubkey);
1171                     var hexAddress = addressBuffer.toString('hex');
1172                     // Use chainId based on selected network
1173                     // Ref: https://developers.rsk.co/rsk/architecture/account-based/#chainid
1174                     var chainId;
1175                     var rskNetworkName = networks[DOM.network.val()].name;
1176                     switch (rskNetworkName) {
1177                         case "R-BTC - RSK":
1178                             chainId = 30;
1179                             break;
1180                         case "tR-BTC - RSK Testnet":
1181                             chainId = 31;
1182                             break;
1183                         default:
1184                             chainId = null;
1185                     }
1186                     var checksumAddress = toChecksumAddressForRsk(hexAddress, chainId);
1187                     address = libs.ethUtil.addHexPrefix(checksumAddress);
1188                     pubkey = libs.ethUtil.addHexPrefix(pubkey);
1189                     if (hasPrivkey) {
1190                         privkey = libs.ethUtil.bufferToHex(keyPair.d.toBuffer());
1191                     }
1192                 }
1193
1194                 // Handshake values are different
1195                 if (networks[DOM.network.val()].name == "HNS - Handshake") {
1196                     var ring = libs.handshake.KeyRing.fromPublic(keyPair.getPublicKeyBuffer())
1197                     address = ring.getAddress().toString();
1198                 }
1199
1200                 // Stellar is different
1201                 if (networks[DOM.network.val()].name == "XLM - Stellar") {
1202                     var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
1203                     var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
1204                     var path = "m/";
1205                         path += purpose + "'/";
1206                         path += coin + "'/" + index + "'";
1207                     var keypair = libs.stellarUtil.getKeypair(path, seed);
1208                     indexText = path;
1209                     privkey = keypair.secret();
1210                     pubkey = address = keypair.publicKey();
1211                 }
1212
1213                 // Nano currency
1214                 if (networks[DOM.network.val()].name == "NANO - Nano") {
1215                     var nanoKeypair = libs.nanoUtil.getKeypair(index, seed);
1216                     privkey = nanoKeypair.privKey;
1217                     pubkey = nanoKeypair.pubKey;
1218                     address = nanoKeypair.address;
1219                 }
1220
1221                 if ((networks[DOM.network.val()].name == "NAS - Nebulas")) {
1222                     var privKeyBuffer = keyPair.d.toBuffer(32);
1223                     var nebulasAccount = libs.nebulas.Account.NewAccount();
1224                     nebulasAccount.setPrivateKey(privKeyBuffer);
1225                     address = nebulasAccount.getAddressString();
1226                     privkey = nebulasAccount.getPrivateKeyString();
1227                     pubkey = nebulasAccount.getPublicKeyString();
1228                 }
1229                 // Ripple values are different
1230                 if (networks[DOM.network.val()].name == "XRP - Ripple") {
1231                     privkey = convertRipplePriv(privkey);
1232                     address = convertRippleAdrr(address);
1233                 }
1234                 // Jingtum values are different
1235                 if (networks[DOM.network.val()].name == "SWTC - Jingtum") {
1236                     privkey = convertJingtumPriv(privkey);
1237                     address = convertJingtumAdrr(address);
1238                 }
1239                 // CasinoCoin values are different
1240                 if (networks[DOM.network.val()].name == "CSC - CasinoCoin") {
1241                     privkey = convertCasinoCoinPriv(privkey);
1242                     address = convertCasinoCoinAdrr(address);
1243                 }
1244                 // Bitcoin Cash address format may vary
1245                 if (networks[DOM.network.val()].name == "BCH - Bitcoin Cash") {
1246                     var bchAddrType = DOM.bitcoinCashAddressType.filter(":checked").val();
1247                     if (bchAddrType == "cashaddr") {
1248                         address = libs.bchaddr.toCashAddress(address);
1249                     }
1250                     else if (bchAddrType == "bitpay") {
1251                         address = libs.bchaddr.toBitpayAddress(address);
1252                     }
1253                 }
1254                  // Bitcoin Cash address format may vary
1255                  if (networks[DOM.network.val()].name == "SLP - Simple Ledger Protocol") {
1256                      var bchAddrType = DOM.bitcoinCashAddressType.filter(":checked").val();
1257                      if (bchAddrType == "cashaddr") {
1258                          address = libs.bchaddrSlp.toSlpAddress(address);
1259                      }
1260                  }
1261                 // Segwit addresses are different
1262                 if (isSegwit) {
1263                     if (!segwitAvailable) {
1264                         return;
1265                     }
1266                     if (isP2wpkh) {
1267                         var keyhash = libs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
1268                         var scriptpubkey = libs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
1269                         address = libs.bitcoin.address.fromOutputScript(scriptpubkey, network)
1270                     }
1271                     else if (isP2wpkhInP2sh) {
1272                         var keyhash = libs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
1273                         var scriptsig = libs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
1274                         var addressbytes = libs.bitcoin.crypto.hash160(scriptsig);
1275                         var scriptpubkey = libs.bitcoin.script.scriptHash.output.encode(addressbytes);
1276                         address = libs.bitcoin.address.fromOutputScript(scriptpubkey, network)
1277                     }
1278                     else if (isP2wsh) {
1279                         // https://github.com/libs.bitcoinjs-lib/blob/v3.3.2/test/integration/addresses.js#L71
1280                         // This is a 1-of-1
1281                         var witnessScript = libs.bitcoin.script.multisig.output.encode(1, [key.getPublicKeyBuffer()]);
1282                         var scriptPubKey = libs.bitcoin.script.witnessScriptHash.output.encode(libs.bitcoin.crypto.sha256(witnessScript));
1283                         address = libs.bitcoin.address.fromOutputScript(scriptPubKey, network);
1284                     }
1285                     else if (isP2wshInP2sh) {
1286                         // https://github.com/libs.bitcoinjs-lib/blob/v3.3.2/test/integration/transactions.js#L183
1287                         // This is a 1-of-1
1288                         var witnessScript = libs.bitcoin.script.multisig.output.encode(1, [key.getPublicKeyBuffer()]);
1289                         var redeemScript = libs.bitcoin.script.witnessScriptHash.output.encode(libs.bitcoin.crypto.sha256(witnessScript));
1290                         var scriptPubKey = libs.bitcoin.script.scriptHash.output.encode(libs.bitcoin.crypto.hash160(redeemScript));
1291                         address = libs.bitcoin.address.fromOutputScript(scriptPubKey, network)
1292                     }
1293                 }
1294
1295                 if ((networks[DOM.network.val()].name == "CRW - Crown")) {
1296                     address = libs.bitcoin.networks.crown.toNewAddress(address);
1297                 }
1298
1299               if (networks[DOM.network.val()].name == "EOS - EOSIO") {
1300                     address = ""
1301                     pubkey = EOSbufferToPublic(keyPair.getPublicKeyBuffer());
1302                     privkey = EOSbufferToPrivate(keyPair.d.toBuffer(32));
1303                 }
1304
1305                 if (networks[DOM.network.val()].name == "FIO - Foundation for Interwallet Operability") {
1306                     address = ""
1307                     pubkey = FIObufferToPublic(keyPair.getPublicKeyBuffer());
1308                     privkey = FIObufferToPrivate(keyPair.d.toBuffer(32));
1309                 }
1310
1311                 //Groestlcoin Addresses are different
1312                 if(isGRS()) {
1313
1314                     if (isSegwit) {
1315                         if (!segwitAvailable) {
1316                             return;
1317                         }
1318                         if (isP2wpkh) {
1319                             address = libs.groestlcoinjs.address.fromOutputScript(scriptpubkey, network)
1320                         }
1321                         else if (isP2wpkhInP2sh) {
1322                             address = libs.groestlcoinjs.address.fromOutputScript(scriptpubkey, network)
1323                         }
1324                     }
1325                     //non-segwit addresses are handled by using groestlcoinjs for bip32RootKey
1326                 }
1327
1328                 if (isELA()) {
1329                     let elaAddress = calcAddressForELA(
1330                         seed,
1331                         parseIntNoNaN(DOM.bip44coin.val(), 0),
1332                         parseIntNoNaN(DOM.bip44account.val(), 0),
1333                         parseIntNoNaN(DOM.bip44change.val(), 0),
1334                         index
1335                     );
1336                     address = elaAddress.address;
1337                     privkey = elaAddress.privateKey;
1338                     pubkey = elaAddress.publicKey;
1339                 }
1340
1341                 addAddressToList(indexText, address, pubkey, privkey);
1342                 if (isLast) {
1343                     hidePending();
1344                     updateCsv();
1345                 }
1346             }, 50)
1347         }
1348
1349         init();
1350
1351     }
1352
1353     function showMore() {
1354         var rowsToAdd = parseInt(DOM.rowsToAdd.val());
1355         if (isNaN(rowsToAdd)) {
1356             rowsToAdd = 20;
1357             DOM.rowsToAdd.val("20");
1358         }
1359         var start = parseInt(DOM.moreRowsStartIndex.val())
1360         if (isNaN(start)) {
1361             start = lastIndexInTable() + 1;
1362         }
1363         else {
1364             var newStart = start + rowsToAdd;
1365             DOM.moreRowsStartIndex.val(newStart);
1366         }
1367         if (rowsToAdd > 200) {
1368             var msg = "Generating " + rowsToAdd + " rows could take a while. ";
1369             msg += "Do you want to continue?";
1370             if (!confirm(msg)) {
1371                 return;
1372             }
1373         }
1374         displayAddresses(start, rowsToAdd);
1375     }
1376
1377     function clearDisplay() {
1378         clearAddressesList();
1379         clearKeys();
1380         hideValidationError();
1381     }
1382
1383     function clearAddressesList() {
1384         DOM.addresses.empty();
1385         DOM.csv.val("");
1386         stopGenerating();
1387     }
1388
1389     function stopGenerating() {
1390         while (generationProcesses.length > 0) {
1391             var generation = generationProcesses.shift();
1392             generation.stop();
1393         }
1394     }
1395
1396     function clearKeys() {
1397         clearRootKey();
1398         clearDerivedKeys();
1399     }
1400
1401     function clearRootKey() {
1402         DOM.rootKey.val("");
1403     }
1404
1405     function clearDerivedKeys() {
1406         DOM.extendedPrivKey.val("");
1407         DOM.extendedPubKey.val("");
1408         DOM.bip44accountXprv.val("");
1409         DOM.bip44accountXpub.val("");
1410     }
1411
1412     function addAddressToList(indexText, address, pubkey, privkey) {
1413         var row = $(addressRowTemplate.html());
1414         // Elements
1415         var indexCell = row.find(".index span");
1416         var addressCell = row.find(".address span");
1417         var pubkeyCell = row.find(".pubkey span");
1418         var privkeyCell = row.find(".privkey span");
1419         // Content
1420         indexCell.text(indexText);
1421         addressCell.text(address);
1422         pubkeyCell.text(pubkey);
1423         privkeyCell.text(privkey);
1424         // Visibility
1425         if (!showIndex) {
1426             indexCell.addClass("invisible");
1427         }
1428         if (!showAddress) {
1429             addressCell.addClass("invisible");
1430         }
1431         if (!showPubKey) {
1432             pubkeyCell.addClass("invisible");
1433         }
1434         if (!showPrivKey) {
1435             privkeyCell.addClass("invisible");
1436         }
1437         DOM.addresses.append(row);
1438         var rowShowQrEls = row.find("[data-show-qr]");
1439         setQrEvents(rowShowQrEls);
1440     }
1441
1442     function hasStrongRandom() {
1443         return 'crypto' in window && window['crypto'] !== null;
1444     }
1445
1446     function disableForms() {
1447         $("form").on("submit", function(e) {
1448             e.preventDefault();
1449         });
1450     }
1451
1452     function parseIntNoNaN(val, defaultVal) {
1453         var v = parseInt(val);
1454         if (isNaN(v)) {
1455             return defaultVal;
1456         }
1457         return v;
1458     }
1459
1460     function showPending() {
1461         DOM.feedback
1462             .text("Calculating...")
1463             .show();
1464     }
1465
1466     function findNearestWord(word) {
1467         var language = getLanguage();
1468         var words = WORDLISTS[language];
1469         var minDistance = 99;
1470         var closestWord = words[0];
1471         for (var i=0; i<words.length; i++) {
1472             var comparedTo = words[i];
1473             if (comparedTo.indexOf(word) == 0) {
1474                 return comparedTo;
1475             }
1476             var distance = libs.levenshtein.get(word, comparedTo);
1477             if (distance < minDistance) {
1478                 closestWord = comparedTo;
1479                 minDistance = distance;
1480             }
1481         }
1482         return closestWord;
1483     }
1484
1485     function hidePending() {
1486         DOM.feedback
1487             .text("")
1488             .hide();
1489     }
1490
1491     function populateNetworkSelect() {
1492         for (var i=0; i<networks.length; i++) {
1493             var network = networks[i];
1494             var option = $("<option>");
1495             option.attr("value", i);
1496             option.text(network.name);
1497             if (network.name == "BTC - Bitcoin") {
1498                 option.prop("selected", true);
1499             }
1500             DOM.phraseNetwork.append(option);
1501         }
1502     }
1503
1504     function populateClientSelect() {
1505         for (var i=0; i<clients.length; i++) {
1506             var client = clients[i];
1507             var option = $("<option>");
1508             option.attr("value", i);
1509             option.text(client.name);
1510             DOM.bip32Client.append(option);
1511         }
1512     }
1513
1514     function getLanguage() {
1515         var defaultLanguage = "english";
1516         // Try to get from existing phrase
1517         var language = getLanguageFromPhrase();
1518         // Try to get from url if not from phrase
1519         if (language.length == 0) {
1520             language = getLanguageFromUrl();
1521         }
1522         // Default to English if no other option
1523         if (language.length == 0) {
1524             language = defaultLanguage;
1525         }
1526         return language;
1527     }
1528
1529     function getLanguageFromPhrase(phrase) {
1530         // Check if how many words from existing phrase match a language.
1531         var language = "";
1532         if (!phrase) {
1533             phrase = DOM.phrase.val();
1534         }
1535         if (phrase.length > 0) {
1536             var words = phraseToWordArray(phrase);
1537             var languageMatches = {};
1538             for (l in WORDLISTS) {
1539                 // Track how many words match in this language
1540                 languageMatches[l] = 0;
1541                 for (var i=0; i<words.length; i++) {
1542                     var wordInLanguage = WORDLISTS[l].indexOf(words[i]) > -1;
1543                     if (wordInLanguage) {
1544                         languageMatches[l]++;
1545                     }
1546                 }
1547                 // Find languages with most word matches.
1548                 // This is made difficult due to commonalities between Chinese
1549                 // simplified vs traditional.
1550                 var mostMatches = 0;
1551                 var mostMatchedLanguages = [];
1552                 for (var l in languageMatches) {
1553                     var numMatches = languageMatches[l];
1554                     if (numMatches > mostMatches) {
1555                         mostMatches = numMatches;
1556                         mostMatchedLanguages = [l];
1557                     }
1558                     else if (numMatches == mostMatches) {
1559                         mostMatchedLanguages.push(l);
1560                     }
1561                 }
1562             }
1563             if (mostMatchedLanguages.length > 0) {
1564                 // Use first language and warn if multiple detected
1565                 language = mostMatchedLanguages[0];
1566                 if (mostMatchedLanguages.length > 1) {
1567                     console.warn("Multiple possible languages");
1568                     console.warn(mostMatchedLanguages);
1569                 }
1570             }
1571         }
1572         return language;
1573     }
1574
1575     function getLanguageFromUrl() {
1576         for (var language in WORDLISTS) {
1577             if (window.location.hash.indexOf(language) > -1) {
1578                 return language;
1579             }
1580         }
1581         return "";
1582     }
1583
1584     function setMnemonicLanguage() {
1585         var language = getLanguage();
1586         // Load the bip39 mnemonic generator for this language if required
1587         if (!(language in mnemonics)) {
1588             mnemonics[language] = new Mnemonic(language);
1589         }
1590         mnemonic = mnemonics[language];
1591     }
1592
1593     function convertPhraseToNewLanguage() {
1594         var oldLanguage = getLanguageFromPhrase();
1595         var newLanguage = getLanguageFromUrl();
1596         var oldPhrase = DOM.phrase.val();
1597         var oldWords = phraseToWordArray(oldPhrase);
1598         var newWords = [];
1599         for (var i=0; i<oldWords.length; i++) {
1600             var oldWord = oldWords[i];
1601             var index = WORDLISTS[oldLanguage].indexOf(oldWord);
1602             var newWord = WORDLISTS[newLanguage][index];
1603             newWords.push(newWord);
1604         }
1605         newPhrase = wordArrayToPhrase(newWords);
1606         return newPhrase;
1607     }
1608
1609     // TODO look at jsbip39 - mnemonic.splitWords
1610     function phraseToWordArray(phrase) {
1611         var words = phrase.split(/\s/g);
1612         var noBlanks = [];
1613         for (var i=0; i<words.length; i++) {
1614             var word = words[i];
1615             if (word.length > 0) {
1616                 noBlanks.push(word);
1617             }
1618         }
1619         return noBlanks;
1620     }
1621
1622     // TODO look at jsbip39 - mnemonic.joinWords
1623     function wordArrayToPhrase(words) {
1624         var phrase = words.join(" ");
1625         var language = getLanguageFromPhrase(phrase);
1626         if (language == "japanese") {
1627             phrase = words.join("\u3000");
1628         }
1629         return phrase;
1630     }
1631
1632     function writeSplitPhrase(phrase) {
1633         var wordCount = phrase.split(/\s/g).length;
1634         var left=[];
1635         for (var i=0;i<wordCount;i++) left.push(i);
1636         var group=[[],[],[]],
1637             groupI=-1;
1638         var seed = Math.abs(sjcl.hash.sha256.hash(phrase)[0])% 2147483647;
1639         while (left.length>0) {
1640             groupI=(groupI+1)%3;
1641             seed = seed * 16807 % 2147483647;
1642             var selected=Math.floor(left.length*(seed - 1) / 2147483646);
1643             group[groupI].push(left[selected]);
1644             left.splice(selected,1);
1645         }
1646         var cards=[phrase.split(/\s/g),phrase.split(/\s/g),phrase.split(/\s/g)];
1647         for (var i=0;i<3;i++) {
1648             for (var ii=0;ii<wordCount/3;ii++) cards[i][group[i][ii]]='XXXX';
1649             cards[i]='Card '+(i+1)+': '+wordArrayToPhrase(cards[i]);
1650         }
1651         DOM.phraseSplit.val(cards.join("\r\n"));
1652         var triesPerSecond=10000000000;
1653         var hackTime=Math.pow(2,wordCount*10/3)/triesPerSecond;
1654         var displayRedText = false;
1655         if (hackTime<1) {
1656             hackTime="<1 second";
1657             displayRedText = true;
1658         } else if (hackTime<86400) {
1659             hackTime=Math.floor(hackTime)+" seconds";
1660             displayRedText = true;
1661         } else if(hackTime<31557600) {
1662             hackTime=Math.floor(hackTime/86400)+" days";
1663             displayRedText = true;
1664         } else {
1665             hackTime=Math.floor(hackTime/31557600)+" years";
1666         }
1667         DOM.phraseSplitWarn.html("Time to hack with only one card: "+hackTime);
1668         if (displayRedText) {
1669             DOM.phraseSplitWarn.addClass("text-danger");
1670         } else {
1671             DOM.phraseSplitWarn.removeClass("text-danger");
1672         }
1673     }
1674
1675     function isUsingOwnEntropy() {
1676         return DOM.useEntropy.prop("checked");
1677     }
1678
1679     function setMnemonicFromEntropy() {
1680         clearEntropyFeedback();
1681         // Get entropy value
1682         var entropyStr = DOM.entropy.val();
1683         // Work out minimum base for entropy
1684         var entropy = null;
1685         if (entropyTypeAutoDetect) {
1686             entropy = Entropy.fromString(entropyStr);
1687         }
1688         else {
1689             let base = DOM.entropyTypeInputs.filter(":checked").val();
1690             entropy = Entropy.fromString(entropyStr, base);
1691         }
1692         if (entropy.binaryStr.length == 0) {
1693             return;
1694         }
1695         // Show entropy details
1696         showEntropyFeedback(entropy);
1697         // Use entropy hash if not using raw entropy
1698         var bits = entropy.binaryStr;
1699         var mnemonicLength = DOM.entropyMnemonicLength.val();
1700         if (mnemonicLength != "raw") {
1701             // Get bits by hashing entropy with SHA256
1702             var hash = sjcl.hash.sha256.hash(entropy.cleanStr);
1703             var hex = sjcl.codec.hex.fromBits(hash);
1704             bits = libs.BigInteger.BigInteger.parse(hex, 16).toString(2);
1705             while (bits.length % 256 != 0) {
1706                 bits = "0" + bits;
1707             }
1708             // Truncate hash to suit number of words
1709             mnemonicLength = parseInt(mnemonicLength);
1710             var numberOfBits = 32 * mnemonicLength / 3;
1711             bits = bits.substring(0, numberOfBits);
1712             // show warning for weak entropy override
1713             if (mnemonicLength / 3 * 32 > entropy.binaryStr.length) {
1714                 DOM.entropyWeakEntropyOverrideWarning.removeClass("hidden");
1715             }
1716             else {
1717                 DOM.entropyWeakEntropyOverrideWarning.addClass("hidden");
1718             }
1719         }
1720         else {
1721             // hide warning for weak entropy override
1722             DOM.entropyWeakEntropyOverrideWarning.addClass("hidden");
1723         }
1724         // Discard trailing entropy
1725         var bitsToUse = Math.floor(bits.length / 32) * 32;
1726         var start = bits.length - bitsToUse;
1727         var binaryStr = bits.substring(start);
1728         // Convert entropy string to numeric array
1729         var entropyArr = [];
1730         for (var i=0; i<binaryStr.length / 8; i++) {
1731             var byteAsBits = binaryStr.substring(i*8, i*8+8);
1732             var entropyByte = parseInt(byteAsBits, 2);
1733             entropyArr.push(entropyByte)
1734         }
1735         // Convert entropy array to mnemonic
1736         var phrase = mnemonic.toMnemonic(entropyArr);
1737         // Set the mnemonic in the UI
1738         DOM.phrase.val(phrase);
1739         writeSplitPhrase(phrase);
1740         // Show the word indexes
1741         showWordIndexes();
1742         // Show the checksum
1743         showChecksum();
1744     }
1745
1746     function clearEntropyFeedback() {
1747         DOM.entropyCrackTime.text("...");
1748         DOM.entropyType.text("");
1749         DOM.entropyWordCount.text("0");
1750         DOM.entropyEventCount.text("0");
1751         DOM.entropyBitsPerEvent.text("0");
1752         DOM.entropyBits.text("0");
1753         DOM.entropyFiltered.html("&nbsp;");
1754         DOM.entropyBinary.html("&nbsp;");
1755     }
1756
1757     function showEntropyFeedback(entropy) {
1758         var numberOfBits = entropy.binaryStr.length;
1759         var timeToCrack = "unknown";
1760         try {
1761             var z = libs.zxcvbn(entropy.base.events.join(""));
1762             timeToCrack = z.crack_times_display.offline_fast_hashing_1e10_per_second;
1763             if (z.feedback.warning != "") {
1764                 timeToCrack = timeToCrack + " - " + z.feedback.warning;
1765             };
1766         }
1767         catch (e) {
1768             console.log("Error detecting entropy strength with zxcvbn:");
1769             console.log(e);
1770         }
1771         var entropyTypeStr = getEntropyTypeStr(entropy);
1772         DOM.entropyTypeInputs.attr("checked", false);
1773         DOM.entropyTypeInputs.filter("[value='" + entropyTypeStr + "']").attr("checked", true);
1774         var wordCount = Math.floor(numberOfBits / 32) * 3;
1775         var bitsPerEvent = entropy.bitsPerEvent.toFixed(2);
1776         var spacedBinaryStr = addSpacesEveryElevenBits(entropy.binaryStr);
1777         DOM.entropyFiltered.html(entropy.cleanHtml);
1778         DOM.entropyType.text(entropyTypeStr);
1779         DOM.entropyCrackTime.text(timeToCrack);
1780         DOM.entropyEventCount.text(entropy.base.events.length);
1781         DOM.entropyBits.text(numberOfBits);
1782         DOM.entropyWordCount.text(wordCount);
1783         DOM.entropyBinary.text(spacedBinaryStr);
1784         DOM.entropyBitsPerEvent.text(bitsPerEvent);
1785         // detect and warn of filtering
1786         var rawNoSpaces = DOM.entropy.val().replace(/\s/g, "");
1787         var cleanNoSpaces = entropy.cleanStr.replace(/\s/g, "");
1788         var isFiltered = rawNoSpaces.length != cleanNoSpaces.length;
1789         if (isFiltered) {
1790             DOM.entropyFilterWarning.removeClass('hidden');
1791         }
1792         else {
1793             DOM.entropyFilterWarning.addClass('hidden');
1794         }
1795     }
1796
1797     function getEntropyTypeStr(entropy) {
1798         var typeStr = entropy.base.str;
1799         // Add some detail if these are cards
1800         if (entropy.base.asInt == 52) {
1801             var cardDetail = []; // array of message strings
1802             // Detect duplicates
1803             var dupes = [];
1804             var dupeTracker = {};
1805             for (var i=0; i<entropy.base.events.length; i++) {
1806                 var card = entropy.base.events[i];
1807                 var cardUpper = card.toUpperCase();
1808                 if (cardUpper in dupeTracker) {
1809                     dupes.push(card);
1810                 }
1811                 dupeTracker[cardUpper] = true;
1812             }
1813             if (dupes.length > 0) {
1814                 var dupeWord = "duplicates";
1815                 if (dupes.length == 1) {
1816                     dupeWord = "duplicate";
1817                 }
1818                 var msg = dupes.length + " " + dupeWord + ": " + dupes.slice(0,3).join(" ");
1819                 if (dupes.length > 3) {
1820                     msg += "...";
1821                 }
1822                 cardDetail.push(msg);
1823             }
1824             // Detect full deck
1825             var uniqueCards = [];
1826             for (var uniqueCard in dupeTracker) {
1827                 uniqueCards.push(uniqueCard);
1828             }
1829             if (uniqueCards.length == 52) {
1830                 cardDetail.unshift("full deck");
1831             }
1832             // Detect missing cards
1833             var values = "A23456789TJQK";
1834             var suits = "CDHS";
1835             var missingCards = [];
1836             for (var i=0; i<suits.length; i++) {
1837                 for (var j=0; j<values.length; j++) {
1838                     var card = values[j] + suits[i];
1839                     if (!(card in dupeTracker)) {
1840                         missingCards.push(card);
1841                     }
1842                 }
1843             }
1844             // Display missing cards if six or less, ie clearly going for full deck
1845             if (missingCards.length > 0 && missingCards.length <= 6) {
1846                 var msg = missingCards.length + " missing: " + missingCards.slice(0,3).join(" ");
1847                 if (missingCards.length > 3) {
1848                     msg += "...";
1849                 }
1850                 cardDetail.push(msg);
1851             }
1852             // Add card details to typeStr
1853             if (cardDetail.length > 0) {
1854                 typeStr += " (" + cardDetail.join(", ") + ")";
1855             }
1856         }
1857         return typeStr;
1858     }
1859
1860     function setQrEvents(els) {
1861         els.on("mouseenter", createQr);
1862         els.on("mouseleave", destroyQr);
1863         els.on("click", toggleQr);
1864     }
1865
1866     function createQr(e) {
1867         var content = e.target.textContent || e.target.value;
1868         if (content) {
1869             var qrEl = libs.kjua({
1870                 text: content,
1871                 render: "canvas",
1872                 size: 310,
1873                 ecLevel: 'H',
1874             });
1875             DOM.qrImage.append(qrEl);
1876             if (!showQr) {
1877                 DOM.qrHider.addClass("hidden");
1878             }
1879             else {
1880                 DOM.qrHider.removeClass("hidden");
1881             }
1882             DOM.qrContainer.removeClass("hidden");
1883         }
1884     }
1885
1886     function destroyQr() {
1887         DOM.qrImage.text("");
1888         DOM.qrContainer.addClass("hidden");
1889     }
1890
1891     function toggleQr() {
1892         showQr = !showQr;
1893         DOM.qrHider.toggleClass("hidden");
1894         DOM.qrHint.toggleClass("hidden");
1895     }
1896
1897     function bip44TabSelected() {
1898         return DOM.bip44tab.hasClass("active");
1899     }
1900
1901     function bip32TabSelected() {
1902         return DOM.bip32tab.hasClass("active");
1903     }
1904
1905     function networkIsEthereum() {
1906         var name = networks[DOM.network.val()].name;
1907         return (name == "ETH - Ethereum")
1908                     || (name == "ETC - Ethereum Classic")
1909                     || (name == "EWT - EnergyWeb")
1910                     || (name == "PIRL - Pirl")
1911                     || (name == "MIX - MIX")
1912                     || (name == "MOAC - MOAC")
1913                     || (name == "MUSIC - Musicoin")
1914                     || (name == "POA - Poa")
1915                     || (name == "EXP - Expanse")
1916                     || (name == "CLO - Callisto")
1917                     || (name == "DXN - DEXON")
1918                     || (name == "ELLA - Ellaism")
1919                     || (name == "ESN - Ethersocial Network")
1920                     || (name == "VET - VeChain")
1921                     || (name == "ERE - EtherCore")
1922                     || (name == "BSC - Binance Smart Chain")
1923     }
1924
1925     function networkIsRsk() {
1926         var name = networks[DOM.network.val()].name;
1927         return (name == "R-BTC - RSK")
1928             || (name == "tR-BTC - RSK Testnet");
1929     }
1930
1931     function networkHasSegwit() {
1932         var n = network;
1933         if ("baseNetwork" in network) {
1934             n = libs.bitcoin.networks[network.baseNetwork];
1935         }
1936         // check if only p2wpkh params are required
1937         if (p2wpkhSelected()) {
1938             return "p2wpkh" in n;
1939         }
1940         // check if only p2wpkh-in-p2sh params are required
1941         else if (p2wpkhInP2shSelected()) {
1942             return "p2wpkhInP2sh" in n;
1943         }
1944         // require both if it's unclear which params are required
1945         return "p2wpkh" in n && "p2wpkhInP2sh" in n;
1946     }
1947
1948     function bip49TabSelected() {
1949         return DOM.bip49tab.hasClass("active");
1950     }
1951
1952     function bip84TabSelected() {
1953         return DOM.bip84tab.hasClass("active");
1954     }
1955
1956     function bip141TabSelected() {
1957         return DOM.bip141tab.hasClass("active");
1958     }
1959
1960     function setHdCoin(coinValue) {
1961         DOM.bip44coin.val(coinValue);
1962         DOM.bip49coin.val(coinValue);
1963         DOM.bip84coin.val(coinValue);
1964     }
1965
1966     function showSegwitAvailable() {
1967         DOM.bip49unavailable.addClass("hidden");
1968         DOM.bip49available.removeClass("hidden");
1969         DOM.bip84unavailable.addClass("hidden");
1970         DOM.bip84available.removeClass("hidden");
1971         DOM.bip141unavailable.addClass("hidden");
1972         DOM.bip141available.removeClass("hidden");
1973     }
1974
1975     function showSegwitUnavailable() {
1976         DOM.bip49available.addClass("hidden");
1977         DOM.bip49unavailable.removeClass("hidden");
1978         DOM.bip84available.addClass("hidden");
1979         DOM.bip84unavailable.removeClass("hidden");
1980         DOM.bip141available.addClass("hidden");
1981         DOM.bip141unavailable.removeClass("hidden");
1982     }
1983
1984     function adjustNetworkForSegwit() {
1985         // If segwit is selected the xpub/xprv prefixes need to be adjusted
1986         // to avoid accidentally importing BIP49 xpub to BIP44 watch only
1987         // wallet.
1988         // See https://github.com/iancoleman/bip39/issues/125
1989         var segwitNetworks = null;
1990         // if a segwit network is alread selected, need to use base network to
1991         // look up new parameters
1992         if ("baseNetwork" in network) {
1993             network = libs.bitcoin.networks[network.baseNetwork];
1994         }
1995         // choose the right segwit params
1996         if (p2wpkhSelected() && "p2wpkh" in network) {
1997             network = network.p2wpkh;
1998         }
1999         else if (p2wpkhInP2shSelected() && "p2wpkhInP2sh" in network) {
2000             network = network.p2wpkhInP2sh;
2001         }
2002         else if (p2wshSelected() && "p2wsh" in network) {
2003             network = network.p2wsh;
2004         }
2005         else if (p2wshInP2shSelected() && "p2wshInP2sh" in network) {
2006             network = network.p2wshInP2sh;
2007         }
2008     }
2009
2010     function lastIndexInTable() {
2011         var pathText = DOM.addresses.find(".index").last().text();
2012         var pathBits = pathText.split("/");
2013         var lastBit = pathBits[pathBits.length-1];
2014         var lastBitClean = lastBit.replace("'", "");
2015         return parseInt(lastBitClean);
2016     }
2017
2018     function uint8ArrayToHex(a) {
2019         var s = ""
2020         for (var i=0; i<a.length; i++) {
2021             var h = a[i].toString(16);
2022             while (h.length < 2) {
2023                 h = "0" + h;
2024             }
2025             s = s + h;
2026         }
2027         return s;
2028     }
2029
2030     function showWordIndexes() {
2031         var phrase = DOM.phrase.val();
2032         var words = phraseToWordArray(phrase);
2033         var wordIndexes = [];
2034         var language = getLanguage();
2035         for (var i=0; i<words.length; i++) {
2036             var word = words[i];
2037             var wordIndex = WORDLISTS[language].indexOf(word);
2038             wordIndexes.push(wordIndex);
2039         }
2040         var wordIndexesStr = wordIndexes.join(", ");
2041         DOM.entropyWordIndexes.text(wordIndexesStr);
2042     }
2043
2044     function showChecksum() {
2045         var phrase = DOM.phrase.val();
2046         var words = phraseToWordArray(phrase);
2047         var checksumBitlength = words.length / 3;
2048         var checksum = "";
2049         var binaryStr = "";
2050         var language = getLanguage();
2051         for (var i=words.length-1; i>=0; i--) {
2052             var word = words[i];
2053             var wordIndex = WORDLISTS[language].indexOf(word);
2054             var wordBinary = wordIndex.toString(2);
2055             while (wordBinary.length < 11) {
2056                 wordBinary = "0" + wordBinary;
2057             }
2058             var binaryStr = wordBinary + binaryStr;
2059             if (binaryStr.length >= checksumBitlength) {
2060                 var start = binaryStr.length - checksumBitlength;
2061                 var end = binaryStr.length;
2062                 checksum = binaryStr.substring(start, end);
2063                 // add spaces so the last group is 11 bits, not the first
2064                 checksum = checksum.split("").reverse().join("")
2065                 checksum = addSpacesEveryElevenBits(checksum);
2066                 checksum = checksum.split("").reverse().join("")
2067                 break;
2068             }
2069         }
2070         DOM.entropyChecksum.text(checksum);
2071     }
2072
2073     function updateCsv() {
2074         var tableCsv = "path,address,public key,private key\n";
2075         var rows = DOM.addresses.find("tr");
2076         for (var i=0; i<rows.length; i++) {
2077             var row = $(rows[i]);
2078             var cells = row.find("td");
2079             for (var j=0; j<cells.length; j++) {
2080                 var cell = $(cells[j]);
2081                 if (!cell.children().hasClass("invisible")) {
2082                     tableCsv = tableCsv + cell.text();
2083                 }
2084                 if (j != cells.length - 1) {
2085                     tableCsv = tableCsv + ",";
2086                 }
2087             }
2088             tableCsv = tableCsv + "\n";
2089         }
2090         DOM.csv.val(tableCsv);
2091     }
2092
2093     function addSpacesEveryElevenBits(binaryStr) {
2094         return binaryStr.match(/.{1,11}/g).join(" ");
2095     }
2096
2097     var networks = [
2098         {
2099             name: "AC - Asiacoin",
2100             onSelect: function() {
2101                 network = libs.bitcoin.networks.asiacoin;
2102                 setHdCoin(51);
2103             },
2104         },
2105         {
2106             name: "ACC - Adcoin",
2107             onSelect: function() {
2108                 network = libs.bitcoin.networks.adcoin;
2109                 setHdCoin(161);
2110             },
2111         },
2112         {
2113             name: "AGM - Argoneum",
2114             onSelect: function() {
2115                 network = libs.bitcoin.networks.argoneum;
2116                 setHdCoin(421);
2117             },
2118         },
2119         {
2120             name: "ARYA - Aryacoin",
2121             onSelect: function() {
2122                 network = libs.bitcoin.networks.aryacoin;
2123                 setHdCoin(357);
2124             },
2125         },
2126         {
2127             name: "AUR - Auroracoin",
2128             onSelect: function() {
2129                 network = libs.bitcoin.networks.auroracoin;
2130                 setHdCoin(85);
2131             },
2132         },
2133         {
2134             name: "AXE - Axe",
2135             onSelect: function() {
2136                 network = libs.bitcoin.networks.axe;
2137                 setHdCoin(4242);
2138             },
2139         },
2140         {
2141             name: "ANON - ANON",
2142             onSelect: function() {
2143                 network = libs.bitcoin.networks.anon;
2144                 setHdCoin(220);
2145             },
2146         },
2147         {
2148             name: "BOLI - Bolivarcoin",
2149             onSelect: function() {
2150                 network = libs.bitcoin.networks.bolivarcoin;
2151                 setHdCoin(278);
2152             },
2153         },
2154         {
2155             name: "BCA - Bitcoin Atom",
2156             onSelect: function() {
2157                 network = libs.bitcoin.networks.atom;
2158                 setHdCoin(185);
2159             },
2160         },
2161         {
2162             name: "BCH - Bitcoin Cash",
2163             onSelect: function() {
2164                 DOM.bitcoinCashAddressTypeContainer.removeClass("hidden");
2165                 setHdCoin(145);
2166             },
2167         },
2168         {
2169             name: "BEET - Beetlecoin",
2170             onSelect: function() {
2171                 network = libs.bitcoin.networks.beetlecoin;
2172                 setHdCoin(800);
2173             },
2174         },
2175         {
2176             name: "BELA - Belacoin",
2177             onSelect: function() {
2178                 network = libs.bitcoin.networks.belacoin;
2179                 setHdCoin(73);
2180             },
2181         },
2182         {
2183             name: "BLK - BlackCoin",
2184             onSelect: function() {
2185                 network = libs.bitcoin.networks.blackcoin;
2186                 setHdCoin(10);
2187             },
2188         },
2189         {
2190             name: "BND - Blocknode",
2191             onSelect: function() {
2192                 network = libs.bitcoin.networks.blocknode;
2193                 setHdCoin(2941);
2194             },
2195         },
2196         {
2197             name: "tBND - Blocknode Testnet",
2198             onSelect: function() {
2199                 network = libs.bitcoin.networks.blocknode_testnet;
2200                 setHdCoin(1);
2201             },
2202         },
2203         {
2204             name: "BRIT - Britcoin",
2205             onSelect: function() {
2206                 network = libs.bitcoin.networks.britcoin;
2207                 setHdCoin(70);
2208             },
2209         },
2210         {
2211             name: "BSD - Bitsend",
2212             onSelect: function() {
2213                 network = libs.bitcoin.networks.bitsend;
2214                 setHdCoin(91);
2215             },
2216         },
2217         {
2218             name: "BST - BlockStamp",
2219             onSelect: function() {
2220                 network = libs.bitcoin.networks.blockstamp;
2221                 setHdCoin(254);
2222             },
2223         },
2224         {
2225             name: "BTA - Bata",
2226             onSelect: function() {
2227                 network = libs.bitcoin.networks.bata;
2228                 setHdCoin(89);
2229             },
2230         },
2231         {
2232             name: "BTC - Bitcoin",
2233             onSelect: function() {
2234                 network = libs.bitcoin.networks.bitcoin;
2235                 setHdCoin(0);
2236             },
2237         },
2238         {
2239             name: "BTC - Bitcoin RegTest",
2240             onSelect: function() {
2241                 network = libs.bitcoin.networks.regtest;
2242                 // Using hd coin value 1 based on bip44_coin_type
2243                 // https://github.com/chaintope/bitcoinrb/blob/f1014406f6b8f9b4edcecedc18df70c80df06f11/lib/bitcoin/chainparams/regtest.yml
2244                 setHdCoin(1);
2245             },
2246         },
2247         {
2248             name: "BTC - Bitcoin Testnet",
2249             onSelect: function() {
2250                 network = libs.bitcoin.networks.testnet;
2251                 setHdCoin(1);
2252             },
2253         },
2254         {
2255             name: "BITG - Bitcoin Green",
2256             onSelect: function() {
2257                 network = libs.bitcoin.networks.bitcoingreen;
2258                 setHdCoin(222);
2259             },
2260         },
2261         {
2262             name: "BTCP - Bitcoin Private",
2263             onSelect: function() {
2264                 network = libs.bitcoin.networks.bitcoinprivate;
2265                 setHdCoin(183);
2266             },
2267         },
2268         {
2269             name: "BSC - Binance Smart Chain",
2270             onSelect: function() {
2271                 network = libs.bitcoin.networks.bitcoin;
2272                 setHdCoin(60);
2273             },
2274         },
2275         {
2276             name: "BSV - BitcoinSV",
2277             onSelect: function() {
2278                 network = libs.bitcoin.networks.bitcoinsv;
2279                 setHdCoin(236);
2280             },
2281         },
2282         {
2283             name: "BTCZ - Bitcoinz",
2284             onSelect: function() {
2285                 network = libs.bitcoin.networks.bitcoinz;
2286                 setHdCoin(177);
2287             },
2288         },
2289         {
2290             name: "BTDX - BitCloud",
2291             onSelect: function() {
2292                 network = libs.bitcoin.networks.bitcloud;
2293                 setHdCoin(218);
2294             },
2295         },
2296         {
2297             name: "BTG - Bitcoin Gold",
2298             onSelect: function() {
2299                 network = libs.bitcoin.networks.bgold;
2300                 setHdCoin(156);
2301             },
2302         },
2303         {
2304             name: "BTX - Bitcore",
2305             onSelect: function() {
2306                 network = libs.bitcoin.networks.bitcore;
2307                 setHdCoin(160);
2308             },
2309         },
2310         {
2311             name: "CCN - Cannacoin",
2312             onSelect: function() {
2313                 network = libs.bitcoin.networks.cannacoin;
2314                 setHdCoin(19);
2315             },
2316         },
2317         {
2318             name: "CESC - Cryptoescudo",
2319             onSelect: function() {
2320                 network = libs.bitcoin.networks.cannacoin;
2321                 setHdCoin(111);
2322             },
2323         },
2324         {
2325             name: "CDN - Canadaecoin",
2326             onSelect: function() {
2327                 network = libs.bitcoin.networks.canadaecoin;
2328                 setHdCoin(34);
2329             },
2330         },
2331         {
2332             name: "CLAM - Clams",
2333             onSelect: function() {
2334                 network = libs.bitcoin.networks.clam;
2335                 setHdCoin(23);
2336             },
2337         },
2338         {
2339             name: "CLO - Callisto",
2340             segwitAvailable: false,
2341             onSelect: function() {
2342                 network = libs.bitcoin.networks.bitcoin;
2343                 setHdCoin(820);
2344             },
2345         },
2346         {
2347             name: "CLUB - Clubcoin",
2348             onSelect: function() {
2349                 network = libs.bitcoin.networks.clubcoin;
2350                 setHdCoin(79);
2351             },
2352         },
2353         {
2354             name: "CMP - Compcoin",
2355             onSelect: function() {
2356                 network = libs.bitcoin.networks.compcoin;
2357                 setHdCoin(71);
2358             },
2359         },
2360         {
2361             name: "CPU - CPUchain",
2362             onSelect: function() {
2363                 network = libs.bitcoin.networks.cpuchain;
2364                 setHdCoin(363);
2365             },
2366         },
2367         {
2368             name: "CRAVE - Crave",
2369             onSelect: function() {
2370                 network = libs.bitcoin.networks.crave;
2371                 setHdCoin(186);
2372             },
2373         },
2374         {
2375             name: "CRP - CranePay",
2376             onSelect: function() {
2377                 network = libs.bitcoin.networks.cranepay;
2378                 setHdCoin(2304);
2379             },
2380         },
2381
2382         {
2383             name: "CRW - Crown (Legacy)",
2384             onSelect: function() {
2385                 network = libs.bitcoin.networks.crown;
2386                 setHdCoin(72);
2387             },
2388         },
2389         {
2390             name: "CRW - Crown",
2391             onSelect: function() {
2392                 network = libs.bitcoin.networks.crown;
2393                 setHdCoin(72);
2394             },
2395         },
2396         {
2397             name: "CSC - CasinoCoin",
2398             onSelect: function() {
2399                 network = libs.bitcoin.networks.bitcoin;
2400                 setHdCoin(359);
2401             },
2402         },
2403         {
2404             name: "DASH - Dash",
2405             onSelect: function() {
2406                 network = libs.bitcoin.networks.dash;
2407                 setHdCoin(5);
2408             },
2409         },
2410         {
2411             name: "DASH - Dash Testnet",
2412             onSelect: function() {
2413                 network = libs.bitcoin.networks.dashtn;
2414                 setHdCoin(1);
2415             },
2416         },
2417         {
2418             name: "DFC - Defcoin",
2419             onSelect: function() {
2420                 network = libs.bitcoin.networks.defcoin;
2421                 setHdCoin(1337);
2422             },
2423         },
2424         {
2425             name: "DGB - Digibyte",
2426             onSelect: function() {
2427                 network = libs.bitcoin.networks.digibyte;
2428                 setHdCoin(20);
2429             },
2430         },
2431         {
2432             name: "DGC - Digitalcoin",
2433             onSelect: function() {
2434                 network = libs.bitcoin.networks.digitalcoin;
2435                 setHdCoin(18);
2436             },
2437         },
2438         {
2439             name: "DMD - Diamond",
2440             onSelect: function() {
2441                 network = libs.bitcoin.networks.diamond;
2442                 setHdCoin(152);
2443             },
2444         },
2445         {
2446             name: "DNR - Denarius",
2447             onSelect: function() {
2448                 network = libs.bitcoin.networks.denarius;
2449                 setHdCoin(116);
2450             },
2451         },
2452         {
2453             name: "DOGE - Dogecoin",
2454             onSelect: function() {
2455                 network = libs.bitcoin.networks.dogecoin;
2456                 setHdCoin(3);
2457             },
2458         },
2459         {
2460             name: "DOGEt - Dogecoin Testnet",
2461             onSelect: function() {
2462                 network = libs.bitcoin.networks.dogecointestnet;
2463                 setHdCoin(1);
2464             },
2465         },
2466         {
2467             name: "DXN - DEXON",
2468             onSelect: function() {
2469                 network = libs.bitcoin.networks.bitcoin;
2470                 setHdCoin(237);
2471             },
2472         },
2473         {
2474             name: "ECN - Ecoin",
2475             onSelect: function() {
2476                 network = libs.bitcoin.networks.ecoin;
2477                 setHdCoin(115);
2478             },
2479         },
2480         {
2481             name: "EDRC - Edrcoin",
2482             onSelect: function() {
2483                 network = libs.bitcoin.networks.edrcoin;
2484                 setHdCoin(56);
2485             },
2486         },
2487         {
2488             name: "EFL - Egulden",
2489             onSelect: function() {
2490                 network = libs.bitcoin.networks.egulden;
2491                 setHdCoin(78);
2492             },
2493         },
2494         {
2495             name: "ELA - Elastos",
2496             onSelect: function () {
2497                 network = libs.bitcoin.networks.elastos;
2498                 setHdCoin(2305);
2499             },
2500         },
2501         {
2502             name: "ELLA - Ellaism",
2503             segwitAvailable: false,
2504             onSelect: function() {
2505                 network = libs.bitcoin.networks.bitcoin;
2506                 setHdCoin(163);
2507             },
2508         },
2509         {
2510             name: "EMC2 - Einsteinium",
2511             onSelect: function() {
2512                 network = libs.bitcoin.networks.einsteinium;
2513                 setHdCoin(41);
2514             },
2515         },
2516         {
2517             name: "ERC - Europecoin",
2518             onSelect: function() {
2519                 network = libs.bitcoin.networks.europecoin;
2520                 setHdCoin(151);
2521             },
2522         },
2523         {
2524             name: "EOS - EOSIO",
2525             onSelect: function() {
2526                 network = libs.bitcoin.networks.bitcoin;
2527                 setHdCoin(194);
2528             },
2529         },
2530         {
2531             name: "ERE - EtherCore",
2532             segwitAvailable: false,
2533             onSelect: function() {
2534                 network = libs.bitcoin.networks.bitcoin;
2535                 setHdCoin(466);
2536             },
2537         },
2538         {
2539             name: "ESN - Ethersocial Network",
2540             segwitAvailable: false,
2541             onSelect: function() {
2542                 network = libs.bitcoin.networks.bitcoin;
2543                 setHdCoin(31102);
2544             },
2545         },
2546         {
2547             name: "ETC - Ethereum Classic",
2548             segwitAvailable: false,
2549             onSelect: function() {
2550                 network = libs.bitcoin.networks.bitcoin;
2551                 setHdCoin(61);
2552             },
2553         },
2554         {
2555             name: "ETH - Ethereum",
2556             onSelect: function() {
2557                 network = libs.bitcoin.networks.bitcoin;
2558                 setHdCoin(60);
2559             },
2560           },
2561         {
2562             name: "EWT - EnergyWeb",
2563             onSelect: function() {
2564                 network = libs.bitcoin.networks.bitcoin;
2565                 setHdCoin(246);
2566             },
2567           },
2568         {
2569             name: "EXCL - Exclusivecoin",
2570             onSelect: function() {
2571                 network = libs.bitcoin.networks.exclusivecoin;
2572                 setHdCoin(190);
2573             },
2574         },
2575         {
2576             name: "EXCC - ExchangeCoin",
2577             onSelect: function() {
2578                 network = libs.bitcoin.networks.exchangecoin;
2579                 setHdCoin(0);
2580             },
2581         },
2582         {
2583             name: "EXP - Expanse",
2584             segwitAvailable: false,
2585             onSelect: function() {
2586                 network = libs.bitcoin.networks.bitcoin;
2587                 setHdCoin(40);
2588             },
2589         },
2590         {
2591             name: "FIO - Foundation for Interwallet Operability",
2592             onSelect: function() {
2593                 network = libs.bitcoin.networks.bitcoin;
2594                 setHdCoin(235);
2595             },
2596         },
2597         {
2598             name: "FIX - FIX",
2599             onSelect: function() {
2600                 network = libs.bitcoin.networks.fix;
2601                 setHdCoin(336);
2602             },
2603         },
2604         {
2605             name: "FIX - FIX Testnet",
2606             onSelect: function() {
2607                 network = libs.bitcoin.networks.fixtestnet;
2608                 setHdCoin(1);
2609             },
2610         },
2611         {
2612             name: "FJC - Fujicoin",
2613             onSelect: function() {
2614                 network = libs.bitcoin.networks.fujicoin;
2615                 setHdCoin(75);
2616             },
2617         },
2618         {
2619             name: "FLASH - Flashcoin",
2620             onSelect: function() {
2621                 network = libs.bitcoin.networks.flashcoin;
2622                 setHdCoin(120);
2623             },
2624         },
2625         {
2626             name: "FRST - Firstcoin",
2627             onSelect: function() {
2628                 network = libs.bitcoin.networks.firstcoin;
2629                 setHdCoin(167);
2630             },
2631         },
2632         {
2633             name: "FTC - Feathercoin",
2634             onSelect: function() {
2635                 network = libs.bitcoin.networks.feathercoin;
2636                 setHdCoin(8);
2637             },
2638         },
2639         {
2640             name: "GAME - GameCredits",
2641             onSelect: function() {
2642                 network = libs.bitcoin.networks.game;
2643                 setHdCoin(101);
2644             },
2645         },
2646         {
2647             name: "GBX - Gobyte",
2648             onSelect: function() {
2649                 network = libs.bitcoin.networks.gobyte;
2650                 setHdCoin(176);
2651             },
2652         },
2653         {
2654             name: "GCR - GCRCoin",
2655             onSelect: function() {
2656                 network = libs.bitcoin.networks.gcr;
2657                 setHdCoin(79);
2658             },
2659         },
2660         {
2661             name: "GRC - Gridcoin",
2662             onSelect: function() {
2663                 network = libs.bitcoin.networks.gridcoin;
2664                 setHdCoin(84);
2665             },
2666         },
2667         {
2668             name: "GRS - Groestlcoin",
2669             onSelect: function() {
2670                 network = libs.bitcoin.networks.groestlcoin;
2671                 setHdCoin(17);
2672             },
2673         },
2674         {
2675             name: "GRS - Groestlcoin Testnet",
2676             onSelect: function() {
2677                 network = libs.bitcoin.networks.groestlcointestnet;
2678                 setHdCoin(1);
2679             },
2680         },
2681         {
2682             name: "HNS - Handshake",
2683             onSelect: function() {
2684                 setHdCoin(5353);
2685             },
2686         },
2687         {
2688             name: "HNC - Helleniccoin",
2689             onSelect: function() {
2690                 network = libs.bitcoin.networks.helleniccoin;
2691                 setHdCoin(168);
2692             },
2693         },
2694         {
2695             name: "HUSH - Hush (Legacy)",
2696             onSelect: function() {
2697                 network = libs.bitcoin.networks.hush;
2698                 setHdCoin(197);
2699             },
2700         },
2701         {
2702             name: "HUSH - Hush3",
2703             onSelect: function() {
2704                 network = libs.bitcoin.networks.hush3;
2705                 setHdCoin(197);
2706             },
2707         },
2708         {
2709             name: "INSN - Insane",
2710             onSelect: function() {
2711                 network = libs.bitcoin.networks.insane;
2712                 setHdCoin(68);
2713             },
2714         },
2715         {
2716             name: "IOP - Iop",
2717             onSelect: function() {
2718                 network = libs.bitcoin.networks.iop;
2719                 setHdCoin(66);
2720             },
2721         },
2722         {
2723             name: "IXC - Ixcoin",
2724             onSelect: function() {
2725                 network = libs.bitcoin.networks.ixcoin;
2726                 setHdCoin(86);
2727             },
2728         },
2729         {
2730             name: "JBS - Jumbucks",
2731             onSelect: function() {
2732                 network = libs.bitcoin.networks.jumbucks;
2733                 setHdCoin(26);
2734             },
2735         },
2736         {
2737             name: "KMD - Komodo",
2738             bip49available: false,
2739             onSelect: function() {
2740                 network = libs.bitcoin.networks.komodo;
2741                 setHdCoin(141);
2742             },
2743         },
2744         {
2745             name: "KOBO - Kobocoin",
2746             bip49available: false,
2747             onSelect: function() {
2748                 network = libs.bitcoin.networks.kobocoin;
2749                 setHdCoin(196);
2750             },
2751         },
2752         {
2753             name: "LBC - Library Credits",
2754             onSelect: function() {
2755                 network = libs.bitcoin.networks.lbry;
2756                 setHdCoin(140);
2757             },
2758         },
2759         {
2760             name: "LCC - Litecoincash",
2761             onSelect: function() {
2762                 network = libs.bitcoin.networks.litecoincash;
2763                 setHdCoin(192);
2764             },
2765         },
2766         {
2767             name: "LDCN - Landcoin",
2768             onSelect: function() {
2769                 network = libs.bitcoin.networks.landcoin;
2770                 setHdCoin(63);
2771             },
2772         },
2773         {
2774             name: "LINX - Linx",
2775             onSelect: function() {
2776                 network = libs.bitcoin.networks.linx;
2777                 setHdCoin(114);
2778             },
2779         },
2780         {
2781             name: "LKR - Lkrcoin",
2782             segwitAvailable: false,
2783             onSelect: function() {
2784                 network = libs.bitcoin.networks.lkrcoin;
2785                 setHdCoin(557);
2786             },
2787         },
2788         {
2789             name: "LTC - Litecoin",
2790             onSelect: function() {
2791                 network = libs.bitcoin.networks.litecoin;
2792                 setHdCoin(2);
2793                 DOM.litecoinLtubContainer.removeClass("hidden");
2794             },
2795         },
2796         {
2797             name: "LTCt - Litecoin Testnet",
2798             onSelect: function() {
2799                 network = libs.bitcoin.networks.litecointestnet;
2800                 setHdCoin(1);
2801                 DOM.litecoinLtubContainer.removeClass("hidden");
2802             },
2803         },
2804         {
2805             name: "LTZ - LitecoinZ",
2806             onSelect: function() {
2807                 network = libs.bitcoin.networks.litecoinz;
2808                 setHdCoin(221);
2809             },
2810         },
2811         {
2812             name: "LYNX - Lynx",
2813             onSelect: function() {
2814                 network = libs.bitcoin.networks.lynx;
2815                 setHdCoin(191);
2816             },
2817         },
2818         {
2819             name: "MAZA - Maza",
2820             onSelect: function() {
2821                 network = libs.bitcoin.networks.maza;
2822                 setHdCoin(13);
2823             },
2824         },
2825         {
2826             name: "MEC - Megacoin",
2827             onSelect: function() {
2828                 network = libs.bitcoin.networks.megacoin;
2829                 setHdCoin(217);
2830             },
2831         },
2832         {
2833             name: "MIX - MIX",
2834             segwitAvailable: false,
2835             onSelect: function() {
2836                 network = libs.bitcoin.networks.bitcoin;
2837                 setHdCoin(76);
2838             },
2839         },
2840         {
2841             name: "MNX - Minexcoin",
2842             onSelect: function() {
2843                 network = libs.bitcoin.networks.minexcoin;
2844                 setHdCoin(182);
2845             },
2846         },
2847         {
2848             name: "MONA - Monacoin",
2849             onSelect: function() {
2850                 network = libs.bitcoin.networks.monacoin,
2851                 setHdCoin(22);
2852             },
2853         },
2854         {
2855             name: "MONK - Monkey Project",
2856             onSelect: function() {
2857                 network = libs.bitcoin.networks.monkeyproject,
2858                 setHdCoin(214);
2859             },
2860         },
2861         {
2862             name: "MOAC - MOAC",
2863             segwitAvailable: false,
2864             onSelect: function() {
2865                 network = libs.bitcoin.networks.bitcoin;
2866                 setHdCoin(314);
2867             },
2868         },
2869         {
2870             name: "MUSIC - Musicoin",
2871             segwitAvailable: false,
2872             onSelect: function() {
2873                 network = libs.bitcoin.networks.bitcoin;
2874                 setHdCoin(184);
2875             },
2876         },
2877         {
2878             name: "NANO - Nano",
2879             onSelect: function() {
2880                 network = network = libs.nanoUtil.dummyNetwork;
2881                 setHdCoin(165);
2882             },
2883         },
2884         {
2885             name: "NAV - Navcoin",
2886             onSelect: function() {
2887                 network = libs.bitcoin.networks.navcoin;
2888                 setHdCoin(130);
2889             },
2890         },
2891         {
2892             name: "NAS - Nebulas",
2893             onSelect: function() {
2894                 network = libs.bitcoin.networks.bitcoin;
2895                 setHdCoin(2718);
2896             },
2897         },
2898         {
2899             name: "NEBL - Neblio",
2900             onSelect: function() {
2901                 network = libs.bitcoin.networks.neblio;
2902                 setHdCoin(146);
2903             },
2904         },
2905         {
2906             name: "NEOS - Neoscoin",
2907             onSelect: function() {
2908                 network = libs.bitcoin.networks.neoscoin;
2909                 setHdCoin(25);
2910             },
2911         },
2912         {
2913             name: "NIX - NIX Platform",
2914             onSelect: function() {
2915                 network = libs.bitcoin.networks.nix;
2916                 setHdCoin(400);
2917             },
2918         },
2919         {
2920             name: "NLG - Gulden",
2921             onSelect: function() {
2922                 network = libs.bitcoin.networks.gulden;
2923                 setHdCoin(87);
2924             },
2925         },
2926         {
2927             name: "NMC - Namecoin",
2928             onSelect: function() {
2929                 network = libs.bitcoin.networks.namecoin;
2930                 setHdCoin(7);
2931             },
2932         },
2933         {
2934             name: "NRG - Energi",
2935             onSelect: function() {
2936                 network = libs.bitcoin.networks.energi;
2937                 setHdCoin(204);
2938             },
2939         },
2940         {
2941             name: "NRO - Neurocoin",
2942             onSelect: function() {
2943                 network = libs.bitcoin.networks.neurocoin;
2944                 setHdCoin(110);
2945             },
2946         },
2947         {
2948             name: "NSR - Nushares",
2949             onSelect: function() {
2950                 network = libs.bitcoin.networks.nushares;
2951                 setHdCoin(11);
2952             },
2953         },
2954         {
2955             name: "NYC - Newyorkc",
2956             onSelect: function() {
2957                 network = libs.bitcoin.networks.newyorkc;
2958                 setHdCoin(179);
2959             },
2960         },
2961         {
2962             name: "NVC - Novacoin",
2963             onSelect: function() {
2964                 network = libs.bitcoin.networks.novacoin;
2965                 setHdCoin(50);
2966             },
2967         },
2968         {
2969             name: "OK - Okcash",
2970             onSelect: function() {
2971                 network = libs.bitcoin.networks.okcash;
2972                 setHdCoin(69);
2973             },
2974         },
2975         {
2976             name: "OMNI - Omnicore",
2977             onSelect: function() {
2978                 network = libs.bitcoin.networks.omnicore;
2979                 setHdCoin(200);
2980             },
2981         },
2982         {
2983             name: "ONION - DeepOnion",
2984             onSelect: function() {
2985                 network = libs.bitcoin.networks.deeponion;
2986                 setHdCoin(305);
2987             },
2988         },
2989         {
2990             name: "ONX - Onixcoin",
2991             onSelect: function() {
2992                 network = libs.bitcoin.networks.onixcoin;
2993                 setHdCoin(174);
2994             },
2995         },
2996         {
2997             name: "PHR - Phore",
2998             onSelect: function() {
2999                 network = libs.bitcoin.networks.phore;
3000                 setHdCoin(444);
3001             },
3002         },
3003         {
3004             name: "PINK - Pinkcoin",
3005             onSelect: function() {
3006                 network = libs.bitcoin.networks.pinkcoin;
3007                 setHdCoin(117);
3008             },
3009         },
3010         {
3011             name: "PIRL - Pirl",
3012             segwitAvailable: false,
3013             onSelect: function() {
3014                 network = libs.bitcoin.networks.bitcoin;
3015                 setHdCoin(164);
3016             },
3017         },
3018         {
3019             name: "PIVX - PIVX",
3020             onSelect: function() {
3021                 network = libs.bitcoin.networks.pivx;
3022                 setHdCoin(119);
3023             },
3024         },
3025         {
3026             name: "PIVX - PIVX Testnet",
3027             onSelect: function() {
3028                 network = libs.bitcoin.networks.pivxtestnet;
3029                 setHdCoin(1);
3030             },
3031         },
3032         {
3033             name: "POA - Poa",
3034             segwitAvailable: false,
3035             onSelect: function() {
3036                 network = libs.bitcoin.networks.bitcoin;
3037                 setHdCoin(178);
3038             },
3039         },
3040         {
3041             name: "POSW - POSWcoin",
3042             onSelect: function() {
3043                 network = libs.bitcoin.networks.poswcoin;
3044                 setHdCoin(47);
3045             },
3046         },
3047         {
3048             name: "POT - Potcoin",
3049             onSelect: function() {
3050                 network = libs.bitcoin.networks.potcoin;
3051                 setHdCoin(81);
3052             },
3053         },
3054         {
3055             name: "PPC - Peercoin",
3056             onSelect: function() {
3057                 network = libs.bitcoin.networks.peercoin;
3058                 setHdCoin(6);
3059             },
3060         },
3061         {
3062             name: "PRJ - ProjectCoin",
3063             onSelect: function() {
3064                 network = libs.bitcoin.networks.projectcoin;
3065                 setHdCoin(533);
3066             },
3067         },
3068         {
3069             name: "PSB - Pesobit",
3070             onSelect: function() {
3071                 network = libs.bitcoin.networks.pesobit;
3072                 setHdCoin(62);
3073             },
3074         },
3075         {
3076             name: "PUT - Putincoin",
3077             onSelect: function() {
3078                 network = libs.bitcoin.networks.putincoin;
3079                 setHdCoin(122);
3080             },
3081         },
3082         {
3083             name: "RPD - Rapids",
3084             onSelect: function() {
3085                 network = libs.bitcoin.networks.rapids;
3086                 setHdCoin(320);
3087             },
3088         },
3089         {
3090             name: "RVN - Ravencoin",
3091             onSelect: function() {
3092                 network = libs.bitcoin.networks.ravencoin;
3093                 setHdCoin(175);
3094             },
3095         },
3096         {
3097             name: "R-BTC - RSK",
3098             onSelect: function() {
3099                 network = libs.bitcoin.networks.rsk;
3100                 setHdCoin(137);
3101             },
3102         },
3103         {
3104             name: "tR-BTC - RSK Testnet",
3105             onSelect: function() {
3106                 network = libs.bitcoin.networks.rsktestnet;
3107                 setHdCoin(37310);
3108             },
3109         },
3110         {
3111             name: "RBY - Rubycoin",
3112             onSelect: function() {
3113                 network = libs.bitcoin.networks.rubycoin;
3114                 setHdCoin(16);
3115             },
3116         },
3117         {
3118             name: "RDD - Reddcoin",
3119             onSelect: function() {
3120                 network = libs.bitcoin.networks.reddcoin;
3121                 setHdCoin(4);
3122             },
3123         },
3124         {
3125             name: "RVR - RevolutionVR",
3126             onSelect: function() {
3127                 network = libs.bitcoin.networks.revolutionvr;
3128                 setHdCoin(129);
3129             },
3130         },
3131         {
3132           name: "SAFE - Safecoin",
3133           onSelect: function() {
3134               network = libs.bitcoin.networks.safecoin;
3135               setHdCoin(19165);
3136             },
3137         },
3138         {
3139             name: "SCRIBE - Scribe",
3140             onSelect: function() {
3141                 network = libs.bitcoin.networks.scribe;
3142                 setHdCoin(545);
3143             },
3144         },
3145     {
3146           name: "SLS - Salus",
3147           onSelect: function() {
3148               network = libs.bitcoin.networks.salus;
3149               setHdCoin(63);
3150             },
3151         },
3152         {
3153             name: "SDC - ShadowCash",
3154             onSelect: function() {
3155                 network = libs.bitcoin.networks.shadow;
3156                 setHdCoin(35);
3157             },
3158         },
3159         {
3160             name: "SDC - ShadowCash Testnet",
3161             onSelect: function() {
3162                 network = libs.bitcoin.networks.shadowtn;
3163                 setHdCoin(1);
3164             },
3165         },
3166         {
3167             name: "SLM - Slimcoin",
3168             onSelect: function() {
3169                 network = libs.bitcoin.networks.slimcoin;
3170                 setHdCoin(63);
3171             },
3172         },
3173         {
3174             name: "SLM - Slimcoin Testnet",
3175             onSelect: function() {
3176                 network = libs.bitcoin.networks.slimcointn;
3177                 setHdCoin(111);
3178             },
3179         },
3180         {
3181             name: "SLP - Simple Ledger Protocol",
3182             onSelect: function() {
3183                 DOM.bitcoinCashAddressTypeContainer.removeClass("hidden");
3184                 setHdCoin(245);
3185             },
3186         },
3187         {
3188             name: "SLR - Solarcoin",
3189             onSelect: function() {
3190                 network = libs.bitcoin.networks.solarcoin;
3191                 setHdCoin(58);
3192             },
3193         },
3194         {
3195             name: "SMLY - Smileycoin",
3196             onSelect: function() {
3197                 network = libs.bitcoin.networks.smileycoin;
3198                 setHdCoin(59);
3199             },
3200         },
3201         {
3202             name: "STASH - Stash",
3203             onSelect: function() {
3204                 network = libs.bitcoin.networks.stash;
3205                 setHdCoin(0xC0C0);
3206             },
3207         },
3208         {
3209             name: "STASH - Stash Testnet",
3210             onSelect: function() {
3211                 network = libs.bitcoin.networks.stashtn;
3212                 setHdCoin(0xCAFE);
3213             },
3214         },
3215         {
3216             name: "STRAT - Stratis",
3217             onSelect: function() {
3218                 network = libs.bitcoin.networks.stratis;
3219                 setHdCoin(105);
3220             },
3221         },
3222         {
3223             name: "SUGAR - Sugarchain",
3224             onSelect: function() {
3225                 network = libs.bitcoin.networks.sugarchain;
3226                 setHdCoin(408);
3227             },
3228         },
3229         {
3230             name: "TUGAR - Sugarchain Testnet",
3231             onSelect: function() {
3232                 network = libs.bitcoin.networks.sugarchaintestnet;
3233                 setHdCoin(408);
3234             },
3235         },
3236         {
3237             name: "SWTC - Jingtum",
3238             onSelect: function() {
3239                 network = libs.bitcoin.networks.bitcoin;
3240                 setHdCoin(315);
3241             },
3242         },
3243         {
3244             name: "TSTRAT - Stratis Testnet",
3245             onSelect: function() {
3246                 network = libs.bitcoin.networks.stratistest;
3247                 setHdCoin(105);
3248             },
3249         },
3250         {
3251             name: "SYS - Syscoin",
3252             onSelect: function() {
3253                 network = libs.bitcoin.networks.syscoin;
3254                 setHdCoin(57);
3255             },
3256         },
3257         {
3258             name: "THC - Hempcoin",
3259             onSelect: function() {
3260                 network = libs.bitcoin.networks.hempcoin;
3261                 setHdCoin(113);
3262             },
3263         },
3264         {
3265             name: "THT - Thought",
3266             onSelect: function() {
3267                 network = libs.bitcoin.networks.thought;
3268                 setHdCoin(1618);
3269             },
3270         },
3271         {
3272             name: "TOA - Toa",
3273             onSelect: function() {
3274                 network = libs.bitcoin.networks.toa;
3275                 setHdCoin(159);
3276             },
3277         },
3278         {
3279             name: "TRX - Tron",
3280             onSelect: function() {
3281                 setHdCoin(195);
3282             },
3283         },
3284         {
3285             name: "TWINS - TWINS",
3286             onSelect: function() {
3287                 network = libs.bitcoin.networks.twins;
3288                 setHdCoin(970);
3289             },
3290         },
3291         {
3292             name: "TWINS - TWINS Testnet",
3293             onSelect: function() {
3294                 network = libs.bitcoin.networks.twinstestnet;
3295                 setHdCoin(1);
3296             },
3297         },
3298         {
3299             name: "USC - Ultimatesecurecash",
3300             onSelect: function() {
3301                 network = libs.bitcoin.networks.ultimatesecurecash;
3302                 setHdCoin(112);
3303             },
3304         },
3305         {
3306             name: "USNBT - NuBits",
3307             onSelect: function() {
3308                 network = libs.bitcoin.networks.nubits;
3309                 setHdCoin(12);
3310             },
3311         },
3312         {
3313             name: "UNO - Unobtanium",
3314             onSelect: function() {
3315                 network = libs.bitcoin.networks.unobtanium;
3316                 setHdCoin(92);
3317             },
3318         },
3319         {
3320             name: "VASH - Vpncoin",
3321             onSelect: function() {
3322                 network = libs.bitcoin.networks.vpncoin;
3323                 setHdCoin(33);
3324             },
3325         },
3326         {
3327             name: "VET - VeChain",
3328             onSelect: function() {
3329                 network = libs.bitcoin.networks.bitcoin;
3330                 setHdCoin(818);
3331             },
3332         },
3333         {
3334             name: "VIA - Viacoin",
3335             onSelect: function() {
3336                 network = libs.bitcoin.networks.viacoin;
3337                 setHdCoin(14);
3338             },
3339         },
3340         {
3341             name: "VIA - Viacoin Testnet",
3342             onSelect: function() {
3343                 network = libs.bitcoin.networks.viacointestnet;
3344                 setHdCoin(1);
3345             },
3346         },
3347         {
3348             name: "VIVO - Vivo",
3349             onSelect: function() {
3350                 network = libs.bitcoin.networks.vivo;
3351                 setHdCoin(166);
3352             },
3353         },
3354         {
3355             name: "VTC - Vertcoin",
3356             onSelect: function() {
3357                 network = libs.bitcoin.networks.vertcoin;
3358                 setHdCoin(28);
3359             },
3360         },
3361         {
3362             name: "WGR - Wagerr",
3363             onSelect: function() {
3364                 network = libs.bitcoin.networks.wagerr;
3365                 setHdCoin(7825266);
3366             },
3367         },
3368         {
3369             name: "WC - Wincoin",
3370             onSelect: function() {
3371                 network = libs.bitcoin.networks.wincoin;
3372                 setHdCoin(181);
3373             },
3374         },
3375         {
3376             name: "XAX - Artax",
3377             onSelect: function() {
3378                 network = libs.bitcoin.networks.artax;
3379                 setHdCoin(219);
3380             },
3381         },
3382         {
3383             name: "XBC - Bitcoinplus",
3384             onSelect: function() {
3385                 network = libs.bitcoin.networks.bitcoinplus;
3386                 setHdCoin(65);
3387             },
3388         },
3389         {
3390             name: "XLM - Stellar",
3391             onSelect: function() {
3392                 network = libs.stellarUtil.dummyNetwork;
3393                 setHdCoin(148);
3394             },
3395         },
3396         {
3397             name: "XMY - Myriadcoin",
3398             onSelect: function() {
3399                 network = libs.bitcoin.networks.myriadcoin;
3400                 setHdCoin(90);
3401             },
3402         },
3403         {
3404             name: "XRP - Ripple",
3405             onSelect: function() {
3406                 network = libs.bitcoin.networks.bitcoin;
3407                 setHdCoin(144);
3408             },
3409         },
3410         {
3411             name: "XVC - Vcash",
3412             onSelect: function() {
3413                 network = libs.bitcoin.networks.vcash;
3414                 setHdCoin(127);
3415             },
3416         },
3417         {
3418             name: "XVG - Verge",
3419             onSelect: function() {
3420                 network = libs.bitcoin.networks.verge;
3421                 setHdCoin(77);
3422             },
3423         },
3424         {
3425             name: "XUEZ - Xuez",
3426             segwitAvailable: false,
3427             onSelect: function() {
3428                 network = libs.bitcoin.networks.xuez;
3429                 setHdCoin(225);
3430             },
3431         },
3432         {
3433             name: "XWC - Whitecoin",
3434             onSelect: function() {
3435                 network = libs.bitcoin.networks.whitecoin;
3436                 setHdCoin(155);
3437             },
3438         },
3439         {
3440             name: "XZC - Zcoin",
3441             onSelect: function() {
3442                 network = libs.bitcoin.networks.zcoin;
3443                 setHdCoin(136);
3444             },
3445         },
3446         {
3447             name: "ZCL - Zclassic",
3448             onSelect: function() {
3449                 network = libs.bitcoin.networks.zclassic;
3450                 setHdCoin(147);
3451             },
3452         },
3453         {
3454             name: "ZEC - Zcash",
3455             onSelect: function() {
3456                 network = libs.bitcoin.networks.zcash;
3457                 setHdCoin(133);
3458             },
3459         },
3460         {
3461             name: "ZEN - Horizen",
3462             onSelect: function() {
3463                 network = libs.bitcoin.networks.zencash;
3464                 setHdCoin(121);
3465             },
3466         },
3467     ]
3468
3469     var clients = [
3470         {
3471             name: "Bitcoin Core",
3472             onSelect: function() {
3473                 DOM.bip32path.val("m/0'/0'");
3474                 DOM.hardenedAddresses.prop('checked', true);
3475             },
3476         },
3477         {
3478             name: "blockchain.info",
3479             onSelect: function() {
3480                 DOM.bip32path.val("m/44'/0'/0'");
3481                 DOM.hardenedAddresses.prop('checked', false);
3482             },
3483         },
3484         {
3485             name: "MultiBit HD",
3486             onSelect: function() {
3487                 DOM.bip32path.val("m/0'/0");
3488                 DOM.hardenedAddresses.prop('checked', false);
3489             },
3490         },
3491         {
3492             name: "Coinomi, Ledger",
3493             onSelect: function() {
3494                 DOM.bip32path.val("m/44'/"+DOM.bip44coin.val()+"'/0'");
3495                 DOM.hardenedAddresses.prop('checked', false);
3496             },
3497         }
3498     ]
3499
3500     // RSK - RSK functions - begin
3501     function stripHexPrefix(address) {
3502         if (typeof address !== "string") {
3503             throw new Error("address parameter should be a string.");
3504         }
3505
3506         var hasPrefix = (address.substring(0, 2) === "0x" ||
3507             address.substring(0, 2) === "0X");
3508
3509         return hasPrefix ? address.slice(2) : address;
3510     };
3511
3512     function toChecksumAddressForRsk(address, chainId = null) {
3513         if (typeof address !== "string") {
3514             throw new Error("address parameter should be a string.");
3515         }
3516
3517         if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
3518             throw new Error("Given address is not a valid RSK address: " + address);
3519         }
3520
3521         var stripAddress = stripHexPrefix(address).toLowerCase();
3522         var prefix = chainId != null ? chainId.toString() + "0x" : "";
3523         var keccakHash = libs.ethUtil.keccak256(prefix + stripAddress)
3524             .toString("hex")
3525             .replace(/^0x/i, "");
3526         var checksumAddress = "0x";
3527
3528         for (var i = 0; i < stripAddress.length; i++) {
3529             checksumAddress +=
3530                 parseInt(keccakHash[i], 16) >= 8 ?
3531                 stripAddress[i].toUpperCase() :
3532                 stripAddress[i];
3533         }
3534
3535         return checksumAddress;
3536     }
3537
3538     // RSK - RSK functions - end
3539
3540     // ELA - Elastos functions - begin
3541     function displayBip44InfoForELA() {
3542         if (!isELA()) {
3543             return;
3544         }
3545
3546         var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
3547         var account = parseIntNoNaN(DOM.bip44account.val(), 0);
3548
3549         // Calculate the account extended keys
3550         var accountXprv = libs.elastosjs.getAccountExtendedPrivateKey(seed, coin, account);
3551         var accountXpub = libs.elastosjs.getAccountExtendedPublicKey(seed, coin, account);
3552
3553         // Display the extended keys
3554         DOM.bip44accountXprv.val(accountXprv);
3555         DOM.bip44accountXpub.val(accountXpub);
3556     }
3557
3558     function displayBip32InfoForELA() {
3559         if (!isELA()) {
3560             return;
3561         }
3562
3563         var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
3564         var account = parseIntNoNaN(DOM.bip44account.val(), 0);
3565         var change = parseIntNoNaN(DOM.bip44change.val(), 0);
3566
3567         DOM.extendedPrivKey.val(libs.elastosjs.getBip32ExtendedPrivateKey(seed, coin, account, change));
3568         DOM.extendedPubKey.val(libs.elastosjs.getBip32ExtendedPublicKey(seed, coin, account, change));
3569
3570         // Display the addresses and privkeys
3571         clearAddressesList();
3572         var initialAddressCount = parseInt(DOM.rowsToAdd.val());
3573         displayAddresses(0, initialAddressCount);
3574     }
3575
3576     function calcAddressForELA(seed, coin, account, change, index) {
3577         if (!isELA()) {
3578             return;
3579         }
3580
3581         var publicKey = libs.elastosjs.getDerivedPublicKey(libs.elastosjs.getMasterPublicKey(seed), change, index);
3582         return {
3583             privateKey: libs.elastosjs.getDerivedPrivateKey(seed, coin, account, change, index),
3584             publicKey: publicKey,
3585             address: libs.elastosjs.getAddress(publicKey.toString('hex'))
3586         };
3587     }
3588     // ELA - Elastos functions - end
3589
3590     init();
3591
3592 })();