X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=tests.js;h=ec368cbf4ec018dbbe4502154a49d13c1b48bc76;hb=c6624d51f4e5607202e48903352574c47571baab;hp=7c67b02036e69a5c0089f1733403e531d0e9549b;hpb=abfbe45086a2f1c3cd3e3ab5708812fdc26e1447;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FBIP39.git diff --git a/tests.js b/tests.js index 7c67b02..ec368cb 100644 --- a/tests.js +++ b/tests.js @@ -44,6 +44,37 @@ function waitForGenerate(fn, maxTime) { wait(); } +function waitForFeedback(fn, maxTime) { + if (!maxTime) { + maxTime = testMaxTime; + } + var start = new Date().getTime(); + var wait = function keepWaiting() { + var now = new Date().getTime(); + var hasTimedOut = now - start > maxTime; + if (hasTimedOut) { + console.log("Test timed out"); + fn(); + return; + } + var feedback = page.evaluate(function() { + var feedback = $(".feedback"); + if (feedback.css("display") == "none") { + return ""; + } + return feedback.text(); + }); + var hasFinished = feedback.length > 0 && feedback != "Calculating..."; + if (hasFinished) { + fn(); + } + else { + setTimeout(keepWaiting, 100); + } + } + wait(); +} + function next() { if (tests.length > 0) { var testsStr = tests.length == 1 ? "test" : "tests"; @@ -1135,6 +1166,56 @@ page.open(url, function(status) { }); }, +// Public key is shown +function() { +page.open(url, function(status) { + var expected = "033f5aed5f6cfbafaf223188095b5980814897295f723815fea5d3f4b648d0d0b3"; + // set the phrase + page.evaluate(function() { + $(".phrase").val("abandon abandon ability").trigger("input"); + }); + // get the address + waitForGenerate(function() { + var actual = page.evaluate(function() { + return $(".pubkey:first").text(); + }); + if (actual != expected) { + console.log("Public key is not shown"); + console.log("Expected: " + expected); + console.log("Got: " + actual); + fail(); + } + next(); + }); +}); +}, + +// Public key visibility can be toggled +function() { +page.open(url, function(status) { + // set the phrase + page.evaluate(function() { + $(".phrase").val("abandon abandon ability"); + $(".phrase").trigger("input"); + }); + waitForGenerate(function() { + // toggle public key visibility + page.evaluate(function() { + $(".public-key-toggle").click(); + }); + // check the public key is not visible + var isInvisible = page.evaluate(function() { + return $(".pubkey:first span").hasClass("invisible"); + }); + if (!isInvisible) { + console.log("Toggled public key is visible"); + fail(); + } + next(); + }); +}); +}, + // Private key is shown function() { page.open(url, function(status) { @@ -1372,28 +1453,1150 @@ page.open(url, function(status) { next(); }); }, + // Custom BIP32 root key is used when changing the derivation path +function() { +page.open(url, function(status) { + var expected = "1Nq2Wmu726XHCuGhctEtGmhxo3wzk5wZ1H"; + // set the root key + page.evaluate(function() { + $(".root-key").val("xprv9s21ZrQH143K2jkGDCeTLgRewT9F2pH5JZs2zDmmjXes34geVnFiuNa8KTvY5WoYvdn4Ag6oYRoB6cXtc43NgJAEqDXf51xPm6fhiMCKwpi").trigger("input"); + }); + waitForGenerate(function() { + // change the derivation path + page.evaluate(function() { + $("#account").val("1").trigger("input"); + }); + // check the bip32 root key is used for derivation, not the blank phrase + waitForGenerate(function() { + var actual = page.evaluate(function() { + return $(".address:first").text(); + }); + if (actual != expected) { + console.log("Changing the derivation path does not use BIP32 root key"); + console.log("Expected: " + expected); + console.log("Actual: " + actual); + fail(); + } + next(); + }); + }); +}); +}, // Incorrect mnemonic shows error +function() { +page.open(url, function(status) { + // set the root key + page.evaluate(function() { + $(".phrase").val("abandon abandon abandon").trigger("input"); + }); + waitForFeedback(function() { + // check there is an error shown + var feedback = page.evaluate(function() { + return $(".feedback").text(); + }); + if (feedback.length <= 0) { + console.log("Invalid mnemonic does not show error"); + fail(); + } + next(); + }); +}); +}, + // Incorrect word shows suggested replacement +function() { +page.open(url, function(status) { + // set the root key + page.evaluate(function() { + $(".phrase").val("abandon abandon abiliti").trigger("input"); + }); + // check there is a suggestion shown + waitForFeedback(function() { + var feedback = page.evaluate(function() { + return $(".feedback").text(); + }); + if (feedback.indexOf("did you mean ability?") < 0) { + console.log("Incorrect word does not show suggested replacement"); + console.log("Error: " + error); + fail(); + } + next(); + }); +}); +}, + // Incorrect BIP32 root key shows error +function() { +page.open(url, function(status) { + // set the root key + page.evaluate(function() { + $(".root-key").val("xprv9s21ZrQH143K2jkGDCeTLgRewT9F2pH5JZs2zDmmjXes34geVnFiuNa8KTvY5WoYvdn4Ag6oYRoB6cXtc43NgJAEqDXf51xPm6fhiMCKwpj").trigger("input"); + }); + // check there is an error shown + waitForFeedback(function() { + var feedback = page.evaluate(function() { + return $(".feedback").text(); + }); + if (feedback != "Invalid root key") { + console.log("Invalid root key does not show error"); + console.log("Error: " + error); + fail(); + } + next(); + }); +}); +}, + // Derivation path not starting with m shows error +function() { +page.open(url, function(status) { + // set the mnemonic phrase + page.evaluate(function() { + $(".phrase").val("abandon abandon ability").trigger("input"); + }); + waitForGenerate(function() { + // select the bip32 tab so custom derivation path can be set + page.evaluate(function() { + $("#bip32-tab a").click(); + }); + waitForGenerate(function() { + // set the incorrect derivation path + page.evaluate(function() { + $("#bip32 .path").val("n/0").trigger("input"); + }); + waitForFeedback(function() { + var feedback = page.evaluate(function() { + return $(".feedback").text(); + }); + if (feedback != "First character must be 'm'") { + console.log("Derivation path not starting with m should show error"); + console.log("Error: " + error); + fail(); + } + next(); + }); + }); + }); +}); +}, + // Derivation path containing invalid characters shows useful error +function() { +page.open(url, function(status) { + // set the mnemonic phrase + page.evaluate(function() { + $(".phrase").val("abandon abandon ability").trigger("input"); + }); + waitForGenerate(function() { + // select the bip32 tab so custom derivation path can be set + page.evaluate(function() { + $("#bip32-tab a").click(); + }); + waitForGenerate(function() { + // set the incorrect derivation path + page.evaluate(function() { + $("#bip32 .path").val("m/1/0wrong1/1").trigger("input"); + }); + waitForFeedback(function() { + var feedback = page.evaluate(function() { + return $(".feedback").text(); + }); + if (feedback != "Invalid characters 0wrong1 found at depth 2") { + console.log("Derivation path with invalid characters should show error"); + console.log("Error: " + error); + fail(); + } + next(); + }); + }); + }); +}); +}, // Github Issue 11: Default word length is 15 -// https://github.com/dcpos/bip39/issues/11 +// https://github.com/iancoleman/bip39/issues/11 +function() { +page.open(url, function(status) { + // get the word length + var defaultLength = page.evaluate(function() { + return $(".strength").val(); + }); + if (defaultLength != 15) { + console.log("Default word length is not 15"); + fail(); + } + next(); +}); +}, + // Github Issue 12: Generate more rows with private keys hidden -// https://github.com/dcpos/bip39/issues/12 +// https://github.com/iancoleman/bip39/issues/12 +function() { +page.open(url, function(status) { + // set the phrase + page.evaluate(function() { + $(".phrase").val("abandon abandon ability"); + $(".phrase").trigger("input"); + }); + waitForGenerate(function() { + // toggle private keys hidden, then generate more addresses + page.evaluate(function() { + $(".private-key-toggle").click(); + $(".more").click(); + }); + waitForGenerate(function() { + // check more have been generated + var expected = 40; + var numPrivKeys = page.evaluate(function() { + return $(".privkey").length; + }); + if (numPrivKeys != expected) { + console.log("Wrong number of addresses when clicking 'more' with hidden privkeys"); + console.log("Expected: " + expected); + console.log("Actual: " + numPrivKeys); + fail(); + } + // check no private keys are shown + var numHiddenPrivKeys = page.evaluate(function() { + return $(".privkey span[class=invisible]").length; + }); + if (numHiddenPrivKeys != expected) { + console.log("Generating more does not retain hidden state of privkeys"); + console.log("Expected: " + expected); + console.log("Actual: " + numHiddenPrivKeys); + fail(); + } + next(); + }); + }); +}); +}, // Github Issue 19: Mnemonic is not sensitive to whitespace -// https://github.com/dcpos/bip39/issues/19 - -// Github Issue 23: Use correct derivation path when changing tabs -// https://github.com/dcpos/bip39/issues/23 +// https://github.com/iancoleman/bip39/issues/19 +function() { +page.open(url, function(status) { + // set the phrase + var expected = "xprv9s21ZrQH143K3isaZsWbKVoTtbvd34Y1ZGRugGdMeBGbM3AgBVzTH159mj1cbbtYSJtQr65w6L5xy5L9SFC7c9VJZWHxgAzpj4mun5LhrbC"; + page.evaluate(function() { + var doubleSpace = " "; + $(".phrase").val("urge cat" + doubleSpace + "bid"); + $(".phrase").trigger("input"); + }); + waitForGenerate(function() { + // Check the bip32 root key is correct + var actual = page.evaluate(function() { + return $(".root-key").val(); + }); + if (actual != expected) { + console.log("Mnemonic is sensitive to whitespace"); + console.log("Expected: " + expected); + console.log("Actual: " + actual); + fail(); + } + next(); + }); +}); +}, -// Github Issue 26: When using a Root key derrived altcoins are incorrect -// https://github.com/dcpos/bip39/issues/26 +// Github Issue 23: Part 1: Use correct derivation path when changing tabs +// https://github.com/iancoleman/bip39/issues/23 +function() { +page.open(url, function(status) { + // 1) and 2) set the phrase + page.evaluate(function() { + $(".phrase").val("abandon abandon ability").trigger("input"); + }); + waitForGenerate(function() { + // 3) select bip32 tab + page.evaluate(function() { + $("#bip32-tab a").click(); + }); + waitForGenerate(function() { + // 4) switch from bitcoin to litecoin + page.evaluate(function() { + $(".network").val("2").trigger("change"); + }); + waitForGenerate(function() { + // 5) Check derivation path is displayed correctly + var expected = "m/0/0"; + var actual = page.evaluate(function() { + return $(".index:first").text(); + }); + if (actual != expected) { + console.log("Github Issue 23 Part 1: derivation path display error"); + console.log("Expected: " + expected); + console.log("Actual: " + actual); + fail(); + } + // 5) Check address is displayed correctly + var expected = "LS8MP5LZ5AdzSZveRrjm3aYVoPgnfFh5T5"; + var actual = page.evaluate(function() { + return $(".address:first").text(); + }); + if (actual != expected) { + console.log("Github Issue 23 Part 1: address display error"); + console.log("Expected: " + expected); + console.log("Actual: " + actual); + fail(); + } + next(); + }); + }); + }); +}); +}, + +// Github Issue 23 Part 2: Coin selection in derivation path +// https://github.com/iancoleman/bip39/issues/23#issuecomment-238011920 +function() { +page.open(url, function(status) { + // set the phrase + page.evaluate(function() { + $(".phrase").val("abandon abandon ability").trigger("input"); + }); + waitForGenerate(function() { + // switch from bitcoin to clam + page.evaluate(function() { + $(".network").val("9").trigger("change"); + }); + waitForGenerate(function() { + // check derivation path is displayed correctly + var expected = "m/44'/23'/0'/0/0"; + var actual = page.evaluate(function() { + return $(".index:first").text(); + }); + if (actual != expected) { + console.log("Github Issue 23 Part 2: Coin in BIP44 derivation path is incorrect"); + console.log("Expected: " + expected); + console.log("Actual: " + actual); + fail(); + } + next(); + }); + }); +}); +}, + +// Github Issue 26: When using a Root key derrived altcoins are incorrect +// https://github.com/iancoleman/bip39/issues/26 +function() { +page.open(url, function(status) { + // 1) 2) and 3) set the root key + page.evaluate(function() { + $(".root-key").val("xprv9s21ZrQH143K2jkGDCeTLgRewT9F2pH5JZs2zDmmjXes34geVnFiuNa8KTvY5WoYvdn4Ag6oYRoB6cXtc43NgJAEqDXf51xPm6fhiMCKwpi").trigger("input"); + }); + waitForGenerate(function() { + // 4) switch from bitcoin to viacoin + page.evaluate(function() { + $(".network").val("6").trigger("change"); + }); + waitForGenerate(function() { + // 5) ensure the derived address is correct + var expected = "Vq9Eq4N5SQnjqZvxtxzo7hZPW5XnyJsmXT"; + var actual = page.evaluate(function() { + return $(".address:first").text(); + }); + if (actual != expected) { + console.log("Github Issue 26: address is incorrect when changing networks and using root-key to derive"); + console.log("Expected: " + expected); + console.log("Actual: " + actual); + fail(); + } + next(); + }); + }); +}); +}, + +// Selecting a language with no existing phrase should generate a phrase in +// that language. +function() { +page.open(url, function(status) { + // Select a language + // Need to manually simulate hash being set due to quirk between + // 'click' event triggered by javascript vs triggered by mouse. + // Perhaps look into page.sendEvent + // http://phantomjs.org/api/webpage/method/send-event.html + page.evaluate(function() { + window.location.hash = "#japanese"; + $("a[href='#japanese']").trigger("click"); + }); + waitForGenerate(function() { + // Check the mnemonic is in Japanese + var phrase = page.evaluate(function() { + return $(".phrase").val(); + }); + if (phrase.length <= 0) { + console.log("No Japanese phrase generated"); + fail(); + } + if (phrase.charCodeAt(0) < 128) { + console.log("First character of Japanese phrase is ascii"); + console.log("Phrase: " + phrase); + fail(); + } + next(); + }); +}); +}, + +// Selecting a language with existing phrase should update the phrase to use +// that language. +function() { +page.open(url, function(status) { + // Set the phrase to an English phrase. + page.evaluate(function() { + $(".phrase").val("abandon abandon ability").trigger("input"); + }); + waitForGenerate(function() { + // Change to Italian + // Need to manually simulate hash being set due to quirk between + // 'click' event triggered by javascript vs triggered by mouse. + // Perhaps look into page.sendEvent + // http://phantomjs.org/api/webpage/method/send-event.html + page.evaluate(function() { + window.location.hash = "#italian"; + $("a[href='#italian']").trigger("click"); + }); + waitForGenerate(function() { + // Check only the language changes, not the phrase + var expected = "abaco abaco abbaglio"; + var actual = page.evaluate(function() { + return $(".phrase").val(); + }); + if (actual != expected) { + console.log("Changing language with existing phrase"); + console.log("Expected: " + expected); + console.log("Actual: " + actual); + fail(); + } + // Check the address is correct + var expected = "1Dz5TgDhdki9spa6xbPFbBqv5sjMrx3xgV"; + var actual = page.evaluate(function() { + return $(".address:first").text(); + }); + if (actual != expected) { + console.log("Changing language generates incorrect address"); + console.log("Expected: " + expected); + console.log("Actual: " + actual); + fail(); + } + next(); + }); + }); +}); +}, + +// Suggested replacement for erroneous word in non-English language +function() { +page.open(url, function(status) { + // Set an incorrect phrase in Italian + page.evaluate(function() { + $(".phrase").val("abaco abaco zbbaglio").trigger("input"); + }); + waitForFeedback(function() { + // Check the suggestion is correct + var feedback = page.evaluate(function() { + return $(".feedback").text(); + }); + if (feedback.indexOf("did you mean abbaglio?") < 0) { + console.log("Incorrect Italian word does not show suggested replacement"); + console.log("Error: " + error); + fail(); + } + next(); + }); +}); +}, + + +// Japanese word does not break across lines. +// Point 2 from +// https://github.com/bitcoin/bips/blob/master/bip-0039/bip-0039-wordlists.md#japanese +function() { +page.open(url, function(status) { + hasWordBreakCss = page.content.indexOf("word-break: keep-all;") > -1; + if (!hasWordBreakCss) { + console.log("Japanese words can break across lines mid-word"); + console.log("Check CSS for '.phrase { word-break: keep-all; }'"); + fail(); + } + // Run the next test + next(); +}); +}, + +// Language can be specified at page load using hash value in url +function() { +page.open(url, function(status) { + // Set the page hash as if it were on a fresh page load + page.evaluate(function() { + window.location.hash = "#japanese"; + }); + // Generate a random phrase + page.evaluate(function() { + $(".generate").trigger("click"); + }); + waitForGenerate(function() { + // Check the phrase is in Japanese + var phrase = page.evaluate(function() { + return $(".phrase").val(); + }); + if (phrase.length <= 0) { + console.log("No phrase generated using url hash"); + fail(); + } + if (phrase.charCodeAt(0) < 128) { + console.log("Language not detected from url hash on page load."); + console.log("Phrase: " + phrase); + fail(); + } + next(); + }); +}); +}, + +// Entropy unit tests +function() { +page.open(url, function(status) { + var error = page.evaluate(function() { + var e; + // binary entropy is detected + e = Entropy.fromString("01010101"); + if (e.base.str != "binary") { + return "Binary entropy not detected correctly"; + } + // base6 entropy is detected + e = Entropy.fromString("012345012345"); + if (e.base.str != "base 6") { + return "base6 entropy not detected correctly"; + } + // dice entropy is detected + e = Entropy.fromString("123456123456"); + if (e.base.str != "base 6 (dice)") { + return "dice entropy not detected correctly"; + } + // base10 entropy is detected + e = Entropy.fromString("0123456789"); + if (e.base.str != "base 10") { + return "base10 entropy not detected correctly"; + } + // hex entropy is detected + e = Entropy.fromString("0123456789ABCDEF"); + if (e.base.str != "hexadecimal") { + return "hexadecimal entropy not detected correctly"; + } + // entropy is case insensitive + e = Entropy.fromString("aBcDeF"); + if (e.cleanStr != "aBcDeF") { + return "Entropy should not be case sensitive"; + } + // dice entropy is converted to base6 + e = Entropy.fromString("123456"); + if (e.cleanStr != "012345") { + return "Dice entropy is not automatically converted to base6"; + } + // dice entropy is preferred to base6 if ambiguous + e = Entropy.fromString("12345"); + if (e.base.str != "base 6 (dice)") { + return "dice not used as default over base 6"; + } + // unused characters are ignored + e = Entropy.fromString("fghijkl"); + if (e.cleanStr != "f") { + return "additional characters are not ignored"; + } + // the lowest base is used by default + // 7 could be decimal or hexadecimal, but should be detected as decimal + e = Entropy.fromString("7"); + if (e.base.str != "base 10") { + return "lowest base is not used"; + } + // Hexadecimal representation is returned + e = Entropy.fromString("1010"); + if (e.hexStr != "A") { + return "Hexadecimal representation not returned"; + } + // Leading zeros are retained + e = Entropy.fromString("000A"); + if (e.cleanStr != "000A") { + return "Leading zeros are not retained"; + } + // Leading zeros are correctly preserved for hex in binary string + e = Entropy.fromString("2A"); + if (e.binaryStr != "00101010") { + return "Hex leading zeros are not correct in binary"; + } + // Keyboard mashing results in weak entropy + // Despite being a long string, it's less than 30 bits of entropy + e = Entropy.fromString("aj;se ifj; ask,dfv js;ifj"); + if (e.binaryStr.length >= 30) { + return "Keyboard mashing should produce weak entropy"; + } + return false; + }); + if (error) { + console.log("Entropy unit tests"); + console.log(error); + fail(); + }; + next(); +}); +}, + +// Entropy can be entered by the user +function() { +page.open(url, function(status) { + expected = { + mnemonic: "abandon abandon ability", + address: "1Di3Vp7tBWtyQaDABLAjfWtF6V7hYKJtug", + } + // use entropy + page.evaluate(function() { + $(".use-entropy").prop("checked", true).trigger("change"); + $(".entropy").val("00000000 00000000 00000000 00000000").trigger("input"); + }); + // check the mnemonic is set and address is correct + waitForGenerate(function() { + var actual = page.evaluate(function() { + return { + address: $(".address:first").text(), + mnemonic: $(".phrase").val(), + } + }); + if (actual.mnemonic != expected.mnemonic) { + console.log("Entropy does not generate correct mnemonic"); + console.log("Expected: " + expected.mnemonic); + console.log("Got: " + actual.mnemonic); + fail(); + } + if (actual.address != expected.address) { + console.log("Entropy does not generate correct address"); + console.log("Expected: " + expected.address); + console.log("Got: " + actual.address); + fail(); + } + next(); + }); +}); +}, + +// A warning about entropy is shown to the user, with additional information +function() { +page.open(url, function(status) { + // get text content from entropy sections of page + var hasWarning = page.evaluate(function() { + var entropyText = $(".entropy-container").text(); + var warning = "mnemonic may be insecure"; + if (entropyText.indexOf(warning) == -1) { + return false; + } + var readMoreText = $("#entropy-notes").parent().text(); + var goodSources = "flipping a fair coin, rolling a fair dice, noise measurements etc"; + if (readMoreText.indexOf(goodSources) == -1) { + return false; + } + return true; + }); + // check the warnings and information are shown + if (!hasWarning) { + console.log("Page does not contain warning about using own entropy"); + fail(); + } + next(); +}); +}, + +// The types of entropy available are described to the user +function() { +page.open(url, function(status) { + // get placeholder text for entropy field + var placeholder = page.evaluate(function() { + return $(".entropy").attr("placeholder"); + }); + var options = [ + "binary", + "base 6", + "dice", + "base 10", + "hexadecimal", + ]; + for (var i=0; i -1) { + console.log("Dice entropy value is shown instead of true base 6 value"); + fail(); + } + next(); + }); +}); +}, + +// The number of bits of entropy accumulated is shown +function() { +page.open(url, function(status) { + var tests = { + "0000 0000 0000 0000 0000": "20", + "0": "1", + "0000": "4", + "6": "3", + "7": "3", + "8": "4", + "F": "4", + "29": "5", + "0A": "8", + "1A": "8", // hex is always multiple of 4 bits of entropy + "2A": "8", + "4A": "8", + "8A": "8", + "FA": "8", + "000A": "16", + "2220": "10", + "2221": "9", // uses dice, so entropy is actually 1110 + "2227": "12", + "222F": "16", + "FFFF": "16", + } + // Arrange tests in array so last one can be easily detected + var entropys = []; + var results = []; + for (var entropy in tests) { + entropys.push(entropy); + results.push(tests[entropy]); + } + // use entropy + page.evaluate(function(e) { + $(".use-entropy").prop("checked", true).trigger("change"); + }); + // Run each test + var nextTest = function runNextTest(i) { + var entropy = entropys[i]; + var expected = results[i]; + // set entropy + page.evaluate(function(e) { + $(".addresses").empty(); // bit of a hack, but needed for waitForGenerate + $(".entropy").val(e).trigger("input"); + }, entropy); + // check the number of bits of entropy is shown + waitForGenerate(function() { + var entropyText = page.evaluate(function() { + return $(".entropy-container").text(); + }); + if (entropyText.indexOf("Have " + expected + " bits of entropy") == -1) { + console.log("Accumulated entropy is not shown correctly for " + entropy); + fail(); + } + var isLastTest = i == results.length - 1; + if (isLastTest) { + next(); + } + else { + runNextTest(i+1); + } + }); + } + nextTest(0); +}); +}, + +// The number of bits of entropy to reach the next mnemonic strength is shown +function() { +page.open(url, function(status) { + // use entropy + page.evaluate(function() { + $(".use-entropy").prop("checked", true).trigger("change"); + $(".entropy").val("7654321").trigger("input"); + }); + // check the amount of additional entropy required is shown + waitForGenerate(function() { + var entropyText = page.evaluate(function() { + return $(".entropy-container").text(); + }); + if (entropyText.indexOf("3 more base 10 chars required") == -1) { + console.log("Additional entropy requirement is not shown"); + fail(); + } + next(); + }); +}); +}, + +// The next strength above 0-word mnemonics is considered extremely weak +// The next strength above 3-word mnemonics is considered very weak +// The next strength above 6-word mnemonics is considered weak +// The next strength above 9-word mnemonics is considered strong +// The next strength above 12-word mnemonics is considered very strong +// The next strength above 15-word mnemonics is considered extremely strong +function() { +page.open(url, function(status) { + var tests = [ + { + entropy: "A", + words: 0, + nextStrength: "an extremely weak", + }, + { + entropy: "AAAAAAAA", + words: 3, + nextStrength: "a very weak", + }, + { + entropy: "AAAAAAAA B", + words: 3, + nextStrength: "a very weak", + }, + { + entropy: "AAAAAAAA BBBBBBBB", + words: 6, + nextStrength: "a weak", + }, + { + entropy: "AAAAAAAA BBBBBBBB CCCCCCCC", + words: 9, + nextStrength: "a strong", + }, + { + entropy: "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD", + words: 12, + nextStrength: "a very strong", + }, + { + entropy: "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD EEEEEEEE", + words: 15, + nextStrength: "an extremely strong", + } + ]; + // use entropy + page.evaluate(function() { + $(".use-entropy").prop("checked", true).trigger("change"); + }); + var nextTest = function runNextTest(i) { + test = tests[i]; + page.evaluate(function(e) { + $(".addresses").empty(); + $(".entropy").val(e).trigger("input"); + }, test.entropy); + waitForGenerate(function() { + // check the strength of the current mnemonic + var mnemonic = page.evaluate(function() { + return $(".phrase").val(); + }); + if (test.words == 0) { + if (mnemonic.length > 0) { + console.log("Mnemonic length for " + test.nextStrength + " strength is not " + test.words); + console.log("Mnemonic: " + mnemonic); + fail(); + } + } + else { + if (mnemonic.split(" ").length != test.words) { + console.log("Mnemonic length for " + test.nextStrength + " strength is not " + test.words); + console.log("Mnemonic: " + mnemonic); + fail(); + } + } + // check the strength of the next mnemonic is shown + var entropyText = page.evaluate(function() { + return $(".entropy-container").text(); + }); + if (entropyText.indexOf("required to generate " + test.nextStrength + " mnemonic") == -1) { + console.log("Strength indicator for " + test.nextStrength + " mnemonic is incorrect"); + fail(); + } + var isLastTest = i == tests.length - 1; + if (isLastTest) { + next(); + } + else { + runNextTest(i+1); + } + }); + } + nextTest(0); +}); +}, + +// Entropy is truncated from the right +function() { +page.open(url, function(status) { + var expected = "abandon abandon ability"; + // use entropy + page.evaluate(function() { + $(".use-entropy").prop("checked", true).trigger("change"); + var entropy = "00000000 00000000 00000000 00000000"; + entropy += "11111111 11111111 11111111 1111"; // Missing last byte, only first 8 bytes are used + $(".entropy").val(entropy).trigger("input"); + }); + // check the entropy is truncated from the right + waitForGenerate(function() { + var actual = page.evaluate(function() { + return $(".phrase").val(); + }); + if (actual != expected) { + console.log("Entropy is not truncated from the right"); + console.log("Expected: " + expected); + console.log("Got: " + actual); + fail(); + } + next(); + }); +}); +}, + +// Very large entropy results in very long mnemonics +function() { +page.open(url, function(status) { + // use entropy + page.evaluate(function() { + $(".use-entropy").prop("checked", true).trigger("change"); + var entropy = ""; + // Generate a very long entropy string + for (var i=0; i<33; i++) { + entropy += "AAAAAAAA"; // 3 words * 33 iterations = 99 words + } + $(".entropy").val(entropy).trigger("input"); + }); + // check the mnemonic is very long + waitForGenerate(function() { + var wordCount = page.evaluate(function() { + return $(".phrase").val().split(" ").length; + }); + if (wordCount != 99) { + console.log("Large entropy does not generate long mnemonic"); + console.log("Expected 99 words, got " + wordCount); + fail(); + } + next(); + }); +}); +}, + +// Is compatible with bip32jp entropy +// https://bip32jp.github.io/english/index.html +// NOTES: +// Is incompatible with: +// base 6 with leading zeros +// base 6 wth 12 words / 53 chars +// base 20 +function() { +page.open(url, function(status) { + var expected = "defy trip fatal jaguar mean rack rifle survey satisfy drift twist champion steel wife state furnace night consider glove olympic oblige donor novel left"; + // use entropy + page.evaluate(function() { + $(".use-entropy").prop("checked", true).trigger("change"); + var entropy = "123450123450123450123450123450123450123450123450123450123450123450123450123450123450123450123450123"; + $(".entropy").val(entropy).trigger("input"); + }); + // check the mnemonic matches the expected value from bip32jp + waitForGenerate(function() { + var actual = page.evaluate(function() { + return $(".phrase").val(); + }); + if (actual != expected) { + console.log("Mnemonic does not match bip32jp for base 6 entropy"); + console.log("Expected: " + expected); + console.log("Got: " + actual); + fail(); + } + next(); + }); +}); +}, + +// If you wish to add more tests, do so here... + +// Here is a blank test template +/* + +function() { +page.open(url, function(status) { + // Do something on the page + page.evaluate(function() { + $(".phrase").val("abandon abandon ability").trigger("input"); + }); + waitForGenerate(function() { + // Check the result of doing the thing + var expected = "1Di3Vp7tBWtyQaDABLAjfWtF6V7hYKJtug"; + var actual = page.evaluate(function() { + return $(".address:first").text(); + }); + if (actual != expected) { + console.log("A specific message about what failed"); + console.log("Expected: " + expected); + console.log("Actual: " + actual); + fail(); + } + // Run the next test + next(); + }); +}); +}, + +*/ ];