(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;
var showIndex = true;
var showAddress = true;
+ var showPubKey = true;
var showPrivKey = 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.entropyError = $(".entropy-error");
DOM.phrase = $(".phrase");
DOM.passphrase = $(".passphrase");
+ DOM.generateContainer = $(".generate-container");
DOM.generate = $(".generate");
DOM.seed = $(".seed");
DOM.rootKey = $(".root-key");
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");
function init() {
// Events
DOM.network.on("change", networkChanged);
+ DOM.useEntropy.on("change", setEntropyVisibility);
+ DOM.entropy.on("input", delayedEntropyChanged);
DOM.phrase.on("input", delayedPhraseChanged);
DOM.passphrase.on("input", delayedPhraseChanged);
DOM.generate.on("click", generateClicked);
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);
disableForms();
hidePending();
hideValidationError();
}
}
+ 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();
function phraseChanged() {
showPending();
hideValidationError();
+ setMnemonicLanguage();
// Get the mnemonic phrase
var phrase = DOM.phrase.val();
var errorText = findPhraseErrors(phrase);
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();
+ hideEntropyError();
+ 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) {
}
function generateClicked() {
+ if (isUsingOwnEntropy()) {
+ return;
+ }
clearDisplay();
showPending();
setTimeout(function() {
+ setMnemonicLanguage();
var phrase = generateRandomPhrase();
if (!phrase) {
return;
}, 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");
$("td.address span").toggleClass("invisible");
}
+ function togglePublicKeys() {
+ showPubKey = !showPubKey;
+ $("td.pubkey span").toggleClass("invisible");
+ }
+
function togglePrivateKeys() {
showPrivKey = !showPrivKey;
$("td.privkey span").toggleClass("invisible");
}
function calcBip32RootKeyFromBase58(rootKeyBase58) {
- bip32RootKey = bitcoin.HDNode.fromBase58(rootKeyBase58);
+ bip32RootKey = bitcoin.HDNode.fromBase58(rootKeyBase58, network);
}
function calcBip32ExtendedKey(path) {
}
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";
}
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)
}
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) {
if (!showAddress) {
addressCell.addClass("invisible");
}
+ if (!showPubKey) {
+ pubkeyCell.addClass("invisible");
+ }
if (!showPrivKey) {
privkeyCell.addClass("invisible");
}
}
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++) {
}
}
+ 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() {
+ hideEntropyError();
+ // 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
+ var extraBits = 32 - (entropy.binaryStr.length % 32);
+ var extraChars = Math.ceil(extraBits * Math.log(2) / Math.log(entropy.base.asInt));
+ var words = Math.floor(entropy.binaryStr.length / 32) * 3;
+ var strength = "an extremely weak";
+ if (words >= 3) {
+ strength = "a very weak";
+ }
+ if (words >= 6) {
+ strength = "a weak";
+ }
+ if (words >= 9) {
+ strength = "a strong";
+ }
+ if (words >= 12) {
+ strength = "a very strong";
+ }
+ if (words >= 15) {
+ strength = "an extremely strong";
+ }
+ if (words >= 18) {
+ strength = "an even stronger"
+ }
+ var msg = "Have " + entropy.binaryStr.length + " bits of entropy, " + extraChars + " more " + entropy.base.str + " chars required to generate " + strength + " mnemonic: " + entropy.cleanStr;
+ showEntropyError(msg);
+ // Discard trailing entropy
+ var bitsToUse = Math.floor(entropy.binaryStr.length / 32) * 32;
+ var binaryStr = entropy.binaryStr.substring(0, bitsToUse);
+ // 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 hideEntropyError() {
+ DOM.entropyError.addClass("hidden");
+ }
+
+ function showEntropyError(msg) {
+ DOM.entropyError.text(msg);
+ DOM.entropyError.removeClass("hidden");
+ }
+
var networks = [
{
name: "Bitcoin",
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();