X-Git-Url: https://git.immae.eu/?p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FBIP39.git;a=blobdiff_plain;f=src%2Fjs%2Findex.js;h=6367c0197fc985bc17d96a8ae15e9387effb89c8;hp=8f7d658dad75b1564a5b41f55c37c18d2a65245e;hb=32fab2c39507357909438c2be8cd100c6539038f;hpb=54563907c721a90f8fc9861a62fe7c214b5c5041

diff --git a/src/js/index.js b/src/js/index.js
index 8f7d658..6367c01 100644
--- a/src/js/index.js
+++ b/src/js/index.js
@@ -1,6 +1,8 @@
 (function() {
 
-    var mnemonic = new Mnemonic("english");
+    // mnemonics is populated as required by getLanguage
+    var mnemonics = { "english": new Mnemonic("english") };
+    var mnemonic = mnemonics["english"];
     var seed = null
     var bip32RootKey = null;
     var bip32ExtendedKey = null;
@@ -9,16 +11,32 @@
 
     var showIndex = true;
     var showAddress = true;
+    var showPubKey = true;
     var showPrivKey = true;
+    var showQr = true;
 
+    var entropyChangeTimeoutEvent = null;
     var phraseChangeTimeoutEvent = null;
     var rootKeyChangedTimeoutEvent = null;
 
     var DOM = {};
     DOM.network = $(".network");
     DOM.phraseNetwork = $("#network-phrase");
+    DOM.useEntropy = $(".use-entropy");
+    DOM.entropyContainer = $(".entropy-container");
+    DOM.entropy = $(".entropy");
+    DOM.entropyFiltered = DOM.entropyContainer.find(".filtered");
+    DOM.entropyType = DOM.entropyContainer.find(".type");
+    DOM.entropyStrength = DOM.entropyContainer.find(".strength");
+    DOM.entropyEventCount = DOM.entropyContainer.find(".event-count");
+    DOM.entropyBits = DOM.entropyContainer.find(".bits");
+    DOM.entropyBitsPerEvent = DOM.entropyContainer.find(".bits-per-event");
+    DOM.entropyWordCount = DOM.entropyContainer.find(".word-count");
+    DOM.entropyBinary = DOM.entropyContainer.find(".binary");
+    DOM.entropyMnemonicLength = DOM.entropyContainer.find(".mnemonic-length");
     DOM.phrase = $(".phrase");
     DOM.passphrase = $(".passphrase");
+    DOM.generateContainer = $(".generate-container");
     DOM.generate = $(".generate");
     DOM.seed = $(".seed");
     DOM.rootKey = $(".root-key");
@@ -34,7 +52,7 @@
     DOM.bip44coin = $("#bip44 .coin");
     DOM.bip44account = $("#bip44 .account");
     DOM.bip44change = $("#bip44 .change");
-    DOM.strength = $(".strength");
+    DOM.generatedStrength = $(".generate-container .strength");
     DOM.hardenedAddresses = $(".hardened-addresses");
     DOM.addresses = $(".addresses");
     DOM.rowsToAdd = $(".rows-to-add");
@@ -43,11 +61,20 @@
     DOM.tab = $(".derivation-type a");
     DOM.indexToggle = $(".index-toggle");
     DOM.addressToggle = $(".address-toggle");
+    DOM.publicKeyToggle = $(".public-key-toggle");
     DOM.privateKeyToggle = $(".private-key-toggle");
+    DOM.languages = $(".languages a");
+    DOM.qrContainer = $(".qr-container");
+    DOM.qrImage = DOM.qrContainer.find(".qr-image");
+    DOM.qrHint = DOM.qrContainer.find(".qr-hint");
+    DOM.showQrEls = $("[data-show-qr]");
 
     function init() {
         // Events
         DOM.network.on("change", networkChanged);
+        DOM.useEntropy.on("change", setEntropyVisibility);
+        DOM.entropy.on("input", delayedEntropyChanged);
+        DOM.entropyMnemonicLength.on("change", entropyChanged);
         DOM.phrase.on("input", delayedPhraseChanged);
         DOM.passphrase.on("input", delayedPhraseChanged);
         DOM.generate.on("click", generateClicked);
@@ -62,7 +89,10 @@
         DOM.hardenedAddresses.on("change", calcForDerivationPath);
         DOM.indexToggle.on("click", toggleIndexes);
         DOM.addressToggle.on("click", toggleAddresses);
+        DOM.publicKeyToggle.on("click", togglePublicKeys);
         DOM.privateKeyToggle.on("click", togglePrivateKeys);
+        DOM.languages.on("click", languageChanged);
+        setQrEvents(DOM.showQrEls);
         disableForms();
         hidePending();
         hideValidationError();
@@ -82,6 +112,22 @@
         }
     }
 
+    function setEntropyVisibility() {
+        if (isUsingOwnEntropy()) {
+            DOM.entropyContainer.removeClass("hidden");
+            DOM.generateContainer.addClass("hidden");
+            DOM.phrase.prop("readonly", true);
+            DOM.entropy.focus();
+            entropyChanged();
+        }
+        else {
+            DOM.entropyContainer.addClass("hidden");
+            DOM.generateContainer.removeClass("hidden");
+            DOM.phrase.prop("readonly", false);
+            hidePending();
+        }
+    }
+
     function delayedPhraseChanged() {
         hideValidationError();
         showPending();
@@ -94,6 +140,7 @@
     function phraseChanged() {
         showPending();
         hideValidationError();
+        setMnemonicLanguage();
         // Get the mnemonic phrase
         var phrase = DOM.phrase.val();
         var errorText = findPhraseErrors(phrase);
@@ -108,6 +155,43 @@
         hidePending();
     }
 
+    function delayedEntropyChanged() {
+        hideValidationError();
+        showPending();
+        if (entropyChangeTimeoutEvent != null) {
+            clearTimeout(entropyChangeTimeoutEvent);
+        }
+        entropyChangeTimeoutEvent = setTimeout(entropyChanged, 400);
+    }
+
+    function entropyChanged() {
+        // If blank entropy, clear mnemonic, addresses, errors
+        if (DOM.entropy.val().trim().length == 0) {
+            clearDisplay();
+            clearEntropyFeedback();
+            DOM.phrase.val("");
+            showValidationError("Blank entropy");
+            return;
+        }
+        // Get the current phrase to detect changes
+        var phrase = DOM.phrase.val();
+        // Set the phrase from the entropy
+        setMnemonicFromEntropy();
+        // Recalc addresses if the phrase has changed
+        var newPhrase = DOM.phrase.val();
+        if (newPhrase != phrase) {
+            if (newPhrase.length == 0) {
+                clearDisplay();
+            }
+            else {
+                phraseChanged();
+            }
+        }
+        else {
+            hidePending();
+        }
+    }
+
     function delayedRootKeyChanged() {
         // Warn if there is an existing mnemonic or passphrase.
         if (DOM.phrase.val().length > 0 || DOM.passphrase.val().length > 0) {
@@ -154,15 +238,19 @@
             showValidationError(errorText);
             return;
         }
-        calcBip32ExtendedKey(derivationPath);
+        bip32ExtendedKey = calcBip32ExtendedKey(derivationPath);
         displayBip32Info();
         hidePending();
     }
 
     function generateClicked() {
+        if (isUsingOwnEntropy()) {
+            return;
+        }
         clearDisplay();
         showPending();
         setTimeout(function() {
+            setMnemonicLanguage();
             var phrase = generateRandomPhrase();
             if (!phrase) {
                 return;
@@ -171,6 +259,20 @@
         }, 50);
     }
 
+    function languageChanged() {
+        setTimeout(function() {
+            setMnemonicLanguage();
+            if (DOM.phrase.val().length > 0) {
+                var newPhrase = convertPhraseToNewLanguage();
+                DOM.phrase.val(newPhrase);
+                phraseChanged();
+            }
+            else {
+                DOM.generate.trigger("click");
+            }
+        }, 50);
+    }
+
     function toggleIndexes() {
         showIndex = !showIndex;
         $("td.index span").toggleClass("invisible");
@@ -181,6 +283,11 @@
         $("td.address span").toggleClass("invisible");
     }
 
+    function togglePublicKeys() {
+        showPubKey = !showPubKey;
+        $("td.pubkey span").toggleClass("invisible");
+    }
+
     function togglePrivateKeys() {
         showPrivKey = !showPrivKey;
         $("td.privkey span").toggleClass("invisible");
@@ -194,7 +301,7 @@
             showValidationError(errorText);
             return;
         }
-        var numWords = parseInt(DOM.strength.val());
+        var numWords = parseInt(DOM.generatedStrength.val());
         var strength = numWords / 3 * 32;
         var words = mnemonic.generate(strength);
         DOM.phrase.val(words);
@@ -207,11 +314,11 @@
     }
 
     function calcBip32RootKeyFromBase58(rootKeyBase58) {
-        bip32RootKey = bitcoin.HDNode.fromBase58(rootKeyBase58);
+        bip32RootKey = bitcoin.HDNode.fromBase58(rootKeyBase58, network);
     }
 
     function calcBip32ExtendedKey(path) {
-        bip32ExtendedKey = bip32RootKey;
+        var extendedKey = bip32RootKey;
         // Derive the key from the path
         var pathBits = path.split("/");
         for (var i=0; i<pathBits.length; i++) {
@@ -222,12 +329,13 @@
             }
             var hardened = bit[bit.length-1] == "'";
             if (hardened) {
-                bip32ExtendedKey = bip32ExtendedKey.deriveHardened(index);
+                extendedKey = extendedKey.deriveHardened(index);
             }
             else {
-                bip32ExtendedKey = bip32ExtendedKey.derive(index);
+                extendedKey = extendedKey.derive(index);
             }
         }
+        return extendedKey
     }
 
     function showValidationError(errorText) {
@@ -243,29 +351,25 @@
     }
 
     function findPhraseErrors(phrase) {
-        // TODO make this right
         // Preprocess the words
         phrase = mnemonic.normalizeString(phrase);
-        var parts = phrase.split(" ");
-        var proper = [];
-        for (var i=0; i<parts.length; i++) {
-            var part = parts[i];
-            if (part.length > 0) {
-                // TODO check that lowercasing is always valid to do
-                proper.push(part.toLowerCase());
-            }
+        var words = phraseToWordArray(phrase);
+        // Detect blank phrase
+        if (words.length == 0) {
+            return "Blank mnemonic";
         }
-        var properPhrase = proper.join(' ');
         // Check each word
-        for (var i=0; i<proper.length; i++) {
-            var word = proper[i];
-            if (WORDLISTS["english"].indexOf(word) == -1) {
+        for (var i=0; i<words.length; i++) {
+            var word = words[i];
+            var language = getLanguage();
+            if (WORDLISTS[language].indexOf(word) == -1) {
                 console.log("Finding closest match to " + word);
                 var nearestWord = findNearestWord(word);
                 return word + " not in wordlist, did you mean " + nearestWord + "?";
             }
         }
         // Check the words are valid
+        var properPhrase = wordArrayToPhrase(words);
         var isValid = mnemonic.check(properPhrase);
         if (!isValid) {
             return "Invalid mnemonic";
@@ -284,7 +388,7 @@
     }
 
     function getDerivationPath() {
-        if (DOM.bip44tab.hasClass("active")) {
+        if (bip44TabSelected()) {
             var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
             var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
             var account = parseIntNoNaN(DOM.bip44account.val(), 0);
@@ -299,7 +403,7 @@
             console.log("Using derivation path from BIP44 tab: " + derivationPath);
             return derivationPath;
         }
-        else if (DOM.bip32tab.hasClass("active")) {
+        else if (bip32TabSelected()) {
             var derivationPath = DOM.bip32path.val();
             console.log("Using derivation path from BIP32 tab: " + derivationPath);
             return derivationPath;
@@ -386,11 +490,12 @@
                 }
                 var address = key.getAddress().toString();
                 var privkey = key.privKey.toWIF(network);
+                var pubkey = key.pubKey.toHex();
                 var indexText = getDerivationPath() + "/" + index;
                 if (useHardenedAddresses) {
                     indexText = indexText + "'";
                 }
-                addAddressToList(indexText, address, privkey);
+                addAddressToList(indexText, address, pubkey, privkey);
             }, 50)
         }
 
@@ -431,15 +536,17 @@
         DOM.extendedPubKey.val("");
     }
 
-    function addAddressToList(indexText, address, privkey) {
+    function addAddressToList(indexText, address, pubkey, privkey) {
         var row = $(addressRowTemplate.html());
         // Elements
         var indexCell = row.find(".index span");
         var addressCell = row.find(".address span");
+        var pubkeyCell = row.find(".pubkey span");
         var privkeyCell = row.find(".privkey span");
         // Content
         indexCell.text(indexText);
         addressCell.text(address);
+        pubkeyCell.text(pubkey);
         privkeyCell.text(privkey);
         // Visibility
         if (!showIndex) {
@@ -448,10 +555,15 @@
         if (!showAddress) {
             addressCell.addClass("invisible");
         }
+        if (!showPubKey) {
+            pubkeyCell.addClass("invisible");
+        }
         if (!showPrivKey) {
             privkeyCell.addClass("invisible");
         }
         DOM.addresses.append(row);
+        var rowShowQrEls = row.find("[data-show-qr]");
+        setQrEvents(rowShowQrEls);
     }
 
     function hasStrongRandom() {
@@ -479,7 +591,8 @@
     }
 
     function findNearestWord(word) {
-        var words = WORDLISTS["english"];
+        var language = getLanguage();
+        var words = WORDLISTS[language];
         var minDistance = 99;
         var closestWord = words[0];
         for (var i=0; i<words.length; i++) {
@@ -509,6 +622,332 @@
         }
     }
 
+    function getLanguage() {
+        var defaultLanguage = "english";
+        // Try to get from existing phrase
+        var language = getLanguageFromPhrase();
+        // Try to get from url if not from phrase
+        if (language.length == 0) {
+            language = getLanguageFromUrl();
+        }
+        // Default to English if no other option
+        if (language.length == 0) {
+            language = defaultLanguage;
+        }
+        return language;
+    }
+
+    function getLanguageFromPhrase(phrase) {
+        // Check if how many words from existing phrase match a language.
+        var language = "";
+        if (!phrase) {
+            phrase = DOM.phrase.val();
+        }
+        if (phrase.length > 0) {
+            var words = phraseToWordArray(phrase);
+            var languageMatches = {};
+            for (l in WORDLISTS) {
+                // Track how many words match in this language
+                languageMatches[l] = 0;
+                for (var i=0; i<words.length; i++) {
+                    var wordInLanguage = WORDLISTS[l].indexOf(words[i]) > -1;
+                    if (wordInLanguage) {
+                        languageMatches[l]++;
+                    }
+                }
+                // Find languages with most word matches.
+                // This is made difficult due to commonalities between Chinese
+                // simplified vs traditional.
+                var mostMatches = 0;
+                var mostMatchedLanguages = [];
+                for (var l in languageMatches) {
+                    var numMatches = languageMatches[l];
+                    if (numMatches > mostMatches) {
+                        mostMatches = numMatches;
+                        mostMatchedLanguages = [l];
+                    }
+                    else if (numMatches == mostMatches) {
+                        mostMatchedLanguages.push(l);
+                    }
+                }
+            }
+            if (mostMatchedLanguages.length > 0) {
+                // Use first language and warn if multiple detected
+                language = mostMatchedLanguages[0];
+                if (mostMatchedLanguages.length > 1) {
+                    console.warn("Multiple possible languages");
+                    console.warn(mostMatchedLanguages);
+                }
+            }
+        }
+        return language;
+    }
+
+    function getLanguageFromUrl() {
+        for (var language in WORDLISTS) {
+            if (window.location.hash.indexOf(language) > -1) {
+                return language;
+            }
+        }
+        return "";
+    }
+
+    function setMnemonicLanguage() {
+        var language = getLanguage();
+        // Load the bip39 mnemonic generator for this language if required
+        if (!(language in mnemonics)) {
+            mnemonics[language] = new Mnemonic(language);
+        }
+        mnemonic = mnemonics[language];
+    }
+
+    function convertPhraseToNewLanguage() {
+        var oldLanguage = getLanguageFromPhrase();
+        var newLanguage = getLanguageFromUrl();
+        var oldPhrase = DOM.phrase.val();
+        var oldWords = phraseToWordArray(oldPhrase);
+        var newWords = [];
+        for (var i=0; i<oldWords.length; i++) {
+            var oldWord = oldWords[i];
+            var index = WORDLISTS[oldLanguage].indexOf(oldWord);
+            var newWord = WORDLISTS[newLanguage][index];
+            newWords.push(newWord);
+        }
+        newPhrase = wordArrayToPhrase(newWords);
+        return newPhrase;
+    }
+
+    // TODO look at jsbip39 - mnemonic.splitWords
+    function phraseToWordArray(phrase) {
+        var words = phrase.split(/\s/g);
+        var noBlanks = [];
+        for (var i=0; i<words.length; i++) {
+            var word = words[i];
+            if (word.length > 0) {
+                noBlanks.push(word);
+            }
+        }
+        return noBlanks;
+    }
+
+    // TODO look at jsbip39 - mnemonic.joinWords
+    function wordArrayToPhrase(words) {
+        var phrase = words.join(" ");
+        var language = getLanguageFromPhrase(phrase);
+        if (language == "japanese") {
+            phrase = words.join("\u3000");
+        }
+        return phrase;
+    }
+
+    function isUsingOwnEntropy() {
+        return DOM.useEntropy.prop("checked");
+    }
+
+    function setMnemonicFromEntropy() {
+        clearEntropyFeedback();
+        // Get entropy value
+        var entropyStr = DOM.entropy.val();
+        // Work out minimum base for entropy
+        var entropy = Entropy.fromString(entropyStr);
+        if (entropy.binaryStr.length == 0) {
+            return;
+        }
+        // Show entropy details
+        showEntropyFeedback(entropy);
+        // Use entropy hash if not using raw entropy
+        var bits = entropy.binaryStr;
+        var mnemonicLength = DOM.entropyMnemonicLength.val();
+        if (mnemonicLength != "raw") {
+            // Get bits by hashing entropy with SHA256
+            var hash = sjcl.hash.sha256.hash(entropy.cleanStr);
+            var hex = sjcl.codec.hex.fromBits(hash);
+            bits = BigInteger.parse(hex, 16).toString(2);
+            for (var i=0; i<256-bits.length; i++) {
+                bits = "0" + bits;
+            }
+            // Truncate hash to suit number of words
+            mnemonicLength = parseInt(mnemonicLength);
+            var numberOfBits = 32 * mnemonicLength / 3;
+            bits = bits.substring(0, numberOfBits);
+        }
+        // Discard trailing entropy
+        var bitsToUse = Math.floor(bits.length / 32) * 32;
+        var start = bits.length - bitsToUse;
+        var binaryStr = bits.substring(start);
+        // Convert entropy string to numeric array
+        var entropyArr = [];
+        for (var i=0; i<binaryStr.length / 8; i++) {
+            var byteAsBits = binaryStr.substring(i*8, i*8+8);
+            var entropyByte = parseInt(byteAsBits, 2);
+            entropyArr.push(entropyByte)
+        }
+        // Convert entropy array to mnemonic
+        var phrase = mnemonic.toMnemonic(entropyArr);
+        // Set the mnemonic in the UI
+        DOM.phrase.val(phrase);
+    }
+
+    function clearEntropyFeedback() {
+        DOM.entropyStrength.text("...");
+        DOM.entropyType.text("");
+        DOM.entropyWordCount.text("0");
+        DOM.entropyEventCount.text("0");
+        DOM.entropyBitsPerEvent.text("0");
+        DOM.entropyBits.text("0");
+        DOM.entropyFiltered.html("&nbsp;");
+        DOM.entropyBinary.html("&nbsp;");
+    }
+
+    function showEntropyFeedback(entropy) {
+        var numberOfBits = entropy.binaryStr.length;
+        var strength = "extremely weak";
+        if (numberOfBits >= 64) {
+            strength = "very weak";
+        }
+        if (numberOfBits >= 96) {
+            strength = "weak";
+        }
+        if (numberOfBits >= 128) {
+            strength = "strong";
+        }
+        if (numberOfBits >= 160) {
+            strength = "very strong";
+        }
+        if (numberOfBits >= 192) {
+            strength = "extremely strong";
+        }
+        // If time to crack is less than one day, and password is considered
+        // strong or better based on the number of bits, rename strength to
+        // 'easily cracked'.
+        try {
+            var z = zxcvbn(entropy.base.parts.join(""));
+            var timeToCrack = z.crack_times_seconds.offline_fast_hashing_1e10_per_second;
+            if (timeToCrack < 86400 && entropy.binaryStr.length >= 128) {
+                strength = "easily cracked";
+                if (z.feedback.warning != "") {
+                    strength = strength + " - " + z.feedback.warning;
+                };
+            }
+        }
+        catch (e) {
+            strength = "unknown";
+            console.log("Error detecting entropy strength with zxcvbn:");
+            console.log(e);
+        }
+        var entropyTypeStr = getEntropyTypeStr(entropy);
+        var wordCount = Math.floor(numberOfBits / 32) * 3;
+        var bitsPerEvent = entropy.bitsPerEvent.toFixed(2);
+        DOM.entropyFiltered.html(entropy.cleanHtml);
+        DOM.entropyType.text(entropyTypeStr);
+        DOM.entropyStrength.text(strength);
+        DOM.entropyEventCount.text(entropy.base.ints.length);
+        DOM.entropyBits.text(numberOfBits);
+        DOM.entropyWordCount.text(wordCount);
+        DOM.entropyBinary.text(entropy.binaryStr);
+        DOM.entropyBitsPerEvent.text(bitsPerEvent);
+    }
+
+    function getEntropyTypeStr(entropy) {
+        var typeStr = entropy.base.str;
+        // Add some detail if these are cards
+        if (entropy.base.asInt == 52) {
+            var cardDetail = []; // array of message strings
+            // Detect duplicates
+            var dupes = [];
+            var dupeTracker = {};
+            for (var i=0; i<entropy.base.parts.length; i++) {
+                var card = entropy.base.parts[i];
+                var cardUpper = card.toUpperCase();
+                if (cardUpper in dupeTracker) {
+                    dupes.push(card);
+                }
+                dupeTracker[cardUpper] = true;
+            }
+            if (dupes.length > 0) {
+                var dupeWord = "duplicates";
+                if (dupes.length == 1) {
+                    dupeWord = "duplicate";
+                }
+                var msg = dupes.length + " " + dupeWord + ": " + dupes.slice(0,3).join(" ");
+                if (dupes.length > 3) {
+                    msg += "...";
+                }
+                cardDetail.push(msg);
+            }
+            // Detect full deck
+            var uniqueCards = [];
+            for (var uniqueCard in dupeTracker) {
+                uniqueCards.push(uniqueCard);
+            }
+            if (uniqueCards.length == 52) {
+                cardDetail.unshift("full deck");
+            }
+            // Detect missing cards
+            var values = "A23456789TJQK";
+            var suits = "CDHS";
+            var missingCards = [];
+            for (var i=0; i<suits.length; i++) {
+                for (var j=0; j<values.length; j++) {
+                    var card = values[j] + suits[i];
+                    if (!(card in dupeTracker)) {
+                        missingCards.push(card);
+                    }
+                }
+            }
+            // Display missing cards if six or less, ie clearly going for full deck
+            if (missingCards.length > 0 && missingCards.length <= 6) {
+                var msg = missingCards.length + " missing: " + missingCards.slice(0,3).join(" ");
+                if (missingCards.length > 3) {
+                    msg += "...";
+                }
+                cardDetail.push(msg);
+            }
+            // Add card details to typeStr
+            if (cardDetail.length > 0) {
+                typeStr += " (" + cardDetail.join(", ") + ")";
+            }
+        }
+        return typeStr;
+    }
+
+    function setQrEvents(els) {
+        els.on("mouseenter", createQr);
+        els.on("mouseleave", destroyQr);
+        els.on("click", toggleQr);
+    }
+
+    function createQr(e) {
+        var content = e.target.textContent || e.target.value;
+        if (content) {
+            var size = 130;
+            DOM.qrImage.qrcode({width: size, height: size, text: content});
+            if (!showQr) {
+                DOM.qrImage.addClass("hidden");
+            }
+            DOM.qrContainer.removeClass("hidden");
+        }
+    }
+
+    function destroyQr() {
+        DOM.qrImage.text("");
+        DOM.qrContainer.addClass("hidden");
+    }
+
+    function toggleQr() {
+        showQr = !showQr;
+        DOM.qrImage.toggleClass("hidden");
+        DOM.qrHint.toggleClass("hidden");
+    }
+
+    function bip44TabSelected() {
+        return DOM.bip44tab.hasClass("active");
+    }
+
+    function bip32TabSelected() {
+        return DOM.bip32tab.hasClass("active");
+    }
+
     var networks = [
         {
             name: "Bitcoin",
@@ -580,6 +1019,27 @@
                 DOM.bip44coin.val(23);
             },
         },
+        {
+            name: "DASH",
+            onSelect: function() {
+                network = bitcoin.networks.dash;
+                DOM.bip44coin.val(5);
+            },
+        },
+        {
+            name: "Namecoin",
+            onSelect: function() {
+                network = bitcoin.networks.namecoin;
+                DOM.bip44coin.val(7);
+            },
+        },
+        {
+            name: "Peercoin",
+            onSelect: function() {
+                network = bitcoin.networks.peercoin;
+                DOM.bip44coin.val(6);
+            },
+        },
     ]
 
     init();