src/js/index.js

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