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 waitForEntropyFeedback(fn, maxTime) {
+ if (!maxTime) {
+ maxTime = testMaxTime;
+ }
+ var origFeedback = page.evaluate(function() {
+ return $(".entropy-error").text();
+ });
+ 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 = $(".entropy-error");
+ if (feedback.css("display") == "none") {
+ return "";
+ }
+ return feedback.text();
+ });
+ var hasFinished = feedback != origFeedback;
+ if (hasFinished) {
+ fn();
+ }
+ else {
+ setTimeout(keepWaiting, 100);
+ }
+ }
+ wait();
+}
+
function next() {
if (tests.length > 0) {
var testsStr = tests.length == 1 ? "test" : "tests";
});
},
+// Network can be set to namecoin
+function() {
+page.open(url, function(status) {
+ // set the phrase and coin
+ var expected = "Mw2vK2Bvex1yYtYF6sfbEg2YGoUc98YUD2";
+ page.evaluate(function() {
+ $(".phrase").val("abandon abandon ability");
+ $(".phrase").trigger("input");
+ $(".network option[selected]").removeAttr("selected");
+ $(".network option[value=11]").prop("selected", true);
+ $(".network").trigger("change");
+ });
+ // check the address is generated correctly
+ waitForGenerate(function() {
+ var actual = page.evaluate(function() {
+ return $(".address:first").text();
+ });
+ if (actual != expected) {
+ console.log("Namecoin address is incorrect");
+ console.log("Expected: " + expected);
+ console.log("Actual: " + actual);
+ fail();
+ }
+ next();
+ });
+});
+},
+
+// Network can be set to peercoin
+function() {
+page.open(url, function(status) {
+ // set the phrase and coin
+ var expected = "PVAiioTaK2eDHSEo3tppT9AVdBYqxRTBAm";
+ page.evaluate(function() {
+ $(".phrase").val("abandon abandon ability");
+ $(".phrase").trigger("input");
+ $(".network option[selected]").removeAttr("selected");
+ $(".network option[value=12]").prop("selected", true);
+ $(".network").trigger("change");
+ });
+ // check the address is generated correctly
+ waitForGenerate(function() {
+ var actual = page.evaluate(function() {
+ return $(".address:first").text();
+ });
+ if (actual != expected) {
+ console.log("Peercoin address is incorrect");
+ console.log("Expected: " + expected);
+ console.log("Actual: " + actual);
+ fail();
+ }
+ next();
+ });
+});
+},
+
// BIP39 seed is set from phrase
function() {
page.open(url, function(status) {
$(".phrase").val("abandon abandon ability");
$(".phrase").trigger("input");
});
- // check the path is not shown
waitForGenerate(function() {
// toggle path visibility
page.evaluate(function() {
},
// Addresses are shown in order of derivation path
-// Address visibility can be toggled
-// Private key is shown
-// Private key visibility can be toggled
-
-// More addresses can be generated
-// A custom number of additional addresses can be generated
-// Additional addresses are shown in order of derivation path
+function() {
+page.open(url, function(status) {
+ // set the phrase
+ page.evaluate(function() {
+ $(".phrase").val("abandon abandon ability").trigger("input");
+ });
+ // get the derivation paths
+ waitForGenerate(function() {
+ var paths = page.evaluate(function() {
+ return $(".index").map(function(i, e) {
+ return $(e).text();
+ });
+ });
+ if (paths.length != 20) {
+ console.log("Total paths is less than expected: " + paths.length);
+ fail();
+ }
+ for (var i=0; i<paths.length; i++) {
+ var expected = "m/44'/0'/0'/0/" + i;
+ var actual = paths[i];
+ if (actual != expected) {
+ console.log("Path " + i + " is incorrect");
+ console.log("Expected: " + expected);
+ console.log("Actual: " + actual);
+ fail();
+ }
+ }
+ next();
+ });
+});
+},
-// BIP32 root key can be set by the user
-// Setting BIP32 root key clears the existing phrase, passphrase and seed
-// Clearing of phrase, passphrase and seed can be cancelled by user
-// Custom BIP32 root key is used when changing the derivation path
+// Address 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 address visibility
+ page.evaluate(function() {
+ $(".address-toggle").click();
+ });
+ // check the address is not visible
+ var isInvisible = page.evaluate(function() {
+ return $(".address:first span").hasClass("invisible");
+ });
+ if (!isInvisible) {
+ console.log("Toggled address is visible");
+ fail();
+ }
+ next();
+ });
+});
+},
-// Incorrect mnemonic shows error
-// Incorrect word shows suggested replacement
-// Incorrect BIP32 root key shows error
-// Derivation path not starting with m shows error
-// Derivation path containing invalid characters shows useful error
+// 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();
+ });
+});
+},
-// Github Issue 11: Default word length is 15
-// https://github.com/dcpos/bip39/issues/11
+// 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();
+ });
+});
+},
-// Github Issue 12: Generate more rows with private keys hidden
-// https://github.com/dcpos/bip39/issues/12
+// Private key is shown
+function() {
+page.open(url, function(status) {
+ var expected = "L26cVSpWFkJ6aQkPkKmTzLqTdLJ923e6CzrVh9cmx21QHsoUmrEE";
+ // set the phrase
+ page.evaluate(function() {
+ $(".phrase").val("abandon abandon ability").trigger("input");
+ });
+ // get the address
+ waitForGenerate(function() {
+ var actual = page.evaluate(function() {
+ return $(".privkey:first").text();
+ });
+ if (actual != expected) {
+ console.log("Private key is not shown");
+ console.log("Expected: " + expected);
+ console.log("Got: " + actual);
+ fail();
+ }
+ next();
+ });
+});
+},
-// Github Issue 19: Mnemonic is not sensitive to whitespace
-// https://github.com/dcpos/bip39/issues/19
+// Private 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 private key visibility
+ page.evaluate(function() {
+ $(".private-key-toggle").click();
+ });
+ // check the private key is not visible
+ var isInvisible = page.evaluate(function() {
+ return $(".privkey:first span").hasClass("invisible");
+ });
+ if (!isInvisible) {
+ console.log("Toggled private key is visible");
+ fail();
+ }
+ next();
+ });
+});
+},
-// Github Issue 23: Use correct derivation path when changing tabs
-// https://github.com/dcpos/bip39/issues/23
+// More addresses can be generated
+function() {
+page.open(url, function(status) {
+ // set the phrase
+ page.evaluate(function() {
+ $(".phrase").val("abandon abandon ability");
+ $(".phrase").trigger("input");
+ });
+ waitForGenerate(function() {
+ // generate more addresses
+ page.evaluate(function() {
+ $(".more").click();
+ });
+ waitForGenerate(function() {
+ // check there are more addresses
+ var addressCount = page.evaluate(function() {
+ return $(".address").length;
+ });
+ if (addressCount != 40) {
+ console.log("More addresses cannot be generated");
+ fail();
+ }
+ next();
+ });
+ });
+});
+},
-// Github Issue 26: When using a Root key derrived altcoins are incorrect
-// https://github.com/dcpos/bip39/issues/26
+// A custom number of additional addresses can be generated
+function() {
+page.open(url, function(status) {
+ // set the phrase
+ page.evaluate(function() {
+ $(".phrase").val("abandon abandon ability");
+ $(".phrase").trigger("input");
+ });
+ waitForGenerate(function() {
+ // get the current number of addresses
+ var oldAddressCount = page.evaluate(function() {
+ return $(".address").length;
+ });
+ // set a custom number of additional addresses
+ page.evaluate(function() {
+ $(".rows-to-add").val(1);
+ });
+ // generate more addresses
+ page.evaluate(function() {
+ $(".more").click();
+ });
+ waitForGenerate(function() {
+ // check there are the correct number of addresses
+ var newAddressCount = page.evaluate(function() {
+ return $(".address").length;
+ });
+ if (newAddressCount - oldAddressCount != 1) {
+ console.log("Number of additional addresses cannot be customized");
+ console.log(newAddressCount)
+ console.log(oldAddressCount)
+ fail();
+ }
+ next();
+ });
+ });
+});
+},
+
+// Additional addresses are shown in order of derivation path
+function() {
+page.open(url, function(status) {
+ // set the phrase
+ page.evaluate(function() {
+ $(".phrase").val("abandon abandon ability").trigger("input");
+ });
+ waitForGenerate(function() {
+ // generate more addresses
+ page.evaluate(function() {
+ $(".more").click();
+ });
+ // get the derivation paths
+ waitForGenerate(function() {
+ var paths = page.evaluate(function() {
+ return $(".index").map(function(i, e) {
+ return $(e).text();
+ });
+ });
+ if (paths.length != 40) {
+ console.log("Total additional paths is less than expected: " + paths.length);
+ fail();
+ }
+ for (var i=0; i<paths.length; i++) {
+ var expected = "m/44'/0'/0'/0/" + i;
+ var actual = paths[i];
+ if (actual != expected) {
+ console.log("Path " + i + " is not in correct order");
+ console.log("Expected: " + expected);
+ console.log("Actual: " + actual);
+ fail();
+ }
+ }
+ next();
+ });
+ });
+});
+},
+
+// BIP32 root key can be set by the user
+function() {
+page.open(url, function(status) {
+ var expected = "1Di3Vp7tBWtyQaDABLAjfWtF6V7hYKJtug";
+ // set the root key
+ page.evaluate(function() {
+ $(".root-key").val("xprv9s21ZrQH143K2jkGDCeTLgRewT9F2pH5JZs2zDmmjXes34geVnFiuNa8KTvY5WoYvdn4Ag6oYRoB6cXtc43NgJAEqDXf51xPm6fhiMCKwpi").trigger("input");
+ });
+ waitForGenerate(function() {
+ var actual = page.evaluate(function() {
+ return $(".address:first").text();
+ });
+ if (actual != expected) {
+ console.log("Setting BIP32 root key results in wrong address");
+ console.log("Expected: " + expected);
+ console.log("Actual: " + actual);
+ fail();
+ }
+ next();
+ });
+});
+},
+
+// Setting BIP32 root key clears the existing phrase, passphrase and seed
+function() {
+page.open(url, function(status) {
+ var expected = "";
+ // set a mnemonic
+ page.evaluate(function() {
+ $(".phrase").val("A non-blank but invalid value");
+ });
+ // Accept any confirm dialogs
+ page.onConfirm = function() {
+ return true;
+ };
+ // set the root key
+ page.evaluate(function() {
+ $(".root-key").val("xprv9s21ZrQH143K2jkGDCeTLgRewT9F2pH5JZs2zDmmjXes34geVnFiuNa8KTvY5WoYvdn4Ag6oYRoB6cXtc43NgJAEqDXf51xPm6fhiMCKwpi").trigger("input");
+ });
+ waitForGenerate(function() {
+ var actual = page.evaluate(function() {
+ return $(".phrase").val();
+ });
+ if (actual != expected) {
+ console.log("Phrase not cleared when setting BIP32 root key");
+ console.log("Expected: " + expected);
+ console.log("Actual: " + actual);
+ fail();
+ }
+ next();
+ });
+});
+},
+
+// Clearing of phrase, passphrase and seed can be cancelled by user
+function() {
+page.open(url, function(status) {
+ var expected = "abandon abandon ability";
+ // set a mnemonic
+ page.evaluate(function() {
+ $(".phrase").val("abandon abandon ability");
+ });
+ // Cancel any confirm dialogs
+ page.onConfirm = function() {
+ return false;
+ };
+ // set the root key
+ page.evaluate(function() {
+ $(".root-key").val("xprv9s21ZrQH143K3d3vzEDD3KpSKmxsZ3y7CqhAL1tinwtP6wqK4TKEKjpBuo6P2hUhB6ZENo7TTSRytiP857hBZVpBdk8PooFuRspE1eywwNZ").trigger("input");
+ });
+ var actual = page.evaluate(function() {
+ return $(".phrase").val();
+ });
+ if (actual != expected) {
+ console.log("Phrase not retained when cancelling changes to BIP32 root key");
+ console.log("Expected: " + expected);
+ console.log("Actual: " + actual);
+ fail();
+ }
+ 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/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/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/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 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 response = page.evaluate(function() {
+ var e;
+ // binary entropy is detected
+ try {
+ e = Entropy.fromString("01010101");
+ if (e.base.str != "binary") {
+ return "Binary entropy not detected correctly";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // base6 entropy is detected
+ try {
+ e = Entropy.fromString("012345012345");
+ if (e.base.str != "base 6") {
+ return "base6 entropy not detected correctly";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // dice entropy is detected
+ try {
+ e = Entropy.fromString("123456123456");
+ if (e.base.str != "base 6 (dice)") {
+ return "dice entropy not detected correctly";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // base10 entropy is detected
+ try {
+ e = Entropy.fromString("0123456789");
+ if (e.base.str != "base 10") {
+ return "base10 entropy not detected correctly";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // hex entropy is detected
+ try {
+ e = Entropy.fromString("0123456789ABCDEF");
+ if (e.base.str != "hexadecimal") {
+ return "hexadecimal entropy not detected correctly";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // card entropy is detected
+ try {
+ e = Entropy.fromString("AC4DTHKS");
+ if (e.base.str != "card") {
+ return "card entropy not detected correctly";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // entropy is case insensitive
+ try {
+ e = Entropy.fromString("aBcDeF");
+ if (e.cleanStr != "aBcDeF") {
+ return "Entropy should not be case sensitive";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // dice entropy is converted to base6
+ try {
+ e = Entropy.fromString("123456");
+ if (e.cleanStr != "012345") {
+ return "Dice entropy is not automatically converted to base6";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // dice entropy is preferred to base6 if ambiguous
+ try {
+ e = Entropy.fromString("12345");
+ if (e.base.str != "base 6 (dice)") {
+ return "dice not used as default over base 6";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // unused characters are ignored
+ try {
+ e = Entropy.fromString("fghijkl");
+ if (e.cleanStr != "f") {
+ return "additional characters are not ignored";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // the lowest base is used by default
+ // 7 could be decimal or hexadecimal, but should be detected as decimal
+ try {
+ e = Entropy.fromString("7");
+ if (e.base.str != "base 10") {
+ return "lowest base is not used";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // Leading zeros are retained
+ try {
+ e = Entropy.fromString("000A");
+ if (e.cleanStr != "000A") {
+ return "Leading zeros are not retained";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // Leading zeros are correctly preserved for hex in binary string
+ try {
+ e = Entropy.fromString("2A");
+ if (e.binaryStr != "00101010") {
+ return "Hex leading zeros are not correct in binary";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // Leading zeros are correctly preserved for base 6 in binary string
+ try {
+ e = Entropy.fromString("2");
+ if (e.binaryStr != "010") {
+ return "Base 6 leading zeros are not correct in binary";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // Keyboard mashing results in weak entropy
+ // Despite being a long string, it's less than 30 bits of entropy
+ try {
+ e = Entropy.fromString("aj;se ifj; ask,dfv js;ifj");
+ if (e.binaryStr.length >= 30) {
+ return "Keyboard mashing should produce weak entropy";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // Card entropy is used if every pair could be a card
+ try {
+ e = Entropy.fromString("4c3c2c");
+ if (e.base.str != "card") {
+ return "Card entropy not used if all pairs are cards";
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ // Card entropy uses base 52
+ // [ cards, binary ]
+ try {
+ var cards = [
+ [ "ac", "00000" ],
+ [ "acac", "00000000000" ],
+ [ "acac2c", "00000000000000001" ],
+ [ "acks", "00000110011" ],
+ [ "acacks", "00000000000110011" ],
+ [ "2c", "000001" ],
+ [ "3d", "001111" ],
+ [ "4h", "011101" ],
+ [ "5s", "101011" ],
+ [ "6c", "000101" ],
+ [ "7d", "010011" ],
+ [ "8h", "100001" ],
+ [ "9s", "101111" ],
+ [ "tc", "001001" ],
+ [ "jd", "010111" ],
+ [ "qh", "100101" ],
+ [ "ks", "110011" ],
+ [ "ks2c", "101001011101" ],
+ [ "KS2C", "101001011101" ],
+ ];
+ for (var i=0; i<cards.length; i++) {
+ var card = cards[i][0];
+ var result = cards[i][1];
+ e = Entropy.fromString(card);
+ console.log(e.binary + " " + result);
+ if (e.binaryStr !== result) {
+ return "card entropy not parsed correctly: " + result + " != " + e.binaryStr;
+ }
+ }
+ }
+ catch (e) {
+ return e.message;
+ }
+ return "PASS";
+ });
+ if (response != "PASS") {
+ console.log("Entropy unit tests");
+ console.log(response);
+ 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<options.length; i++) {
+ var option = options[i];
+ if (placeholder.indexOf(option) == -1) {
+ console.log("Available entropy type is not shown to user: " + option);
+ fail();
+ }
+ }
+ next();
+});
+},
+
+// The actual entropy used is shown to the user
+function() {
+page.open(url, function(status) {
+ // use entropy
+ var badEntropySource = page.evaluate(function() {
+ var entropy = "Not A Very Good Entropy Source At All";
+ $(".use-entropy").prop("checked", true).trigger("change");
+ $(".entropy").val(entropy).trigger("input");
+ });
+ // check the actual entropy being used is shown
+ waitForEntropyFeedback(function() {
+ var expectedText = "AedEceAA";
+ var entropyText = page.evaluate(function() {
+ return $(".entropy-container").text();
+ });
+ if (entropyText.indexOf(expectedText) == -1) {
+ console.log("Actual entropy used is not shown");
+ fail();
+ }
+ next();
+ });
+});
+},
+
+// Binary entropy can be entered
+function() {
+page.open(url, function(status) {
+ // use entropy
+ page.evaluate(function() {
+ $(".use-entropy").prop("checked", true).trigger("change");
+ $(".entropy").val("01").trigger("input");
+ });
+ // check the entropy is shown to be the correct type
+ waitForEntropyFeedback(function() {
+ var entropyText = page.evaluate(function() {
+ return $(".entropy-container").text();
+ });
+ if (entropyText.indexOf("binary") == -1) {
+ console.log("Binary entropy is not detected and presented to user");
+ fail();
+ }
+ next();
+ });
+});
+},
+
+// Base 6 entropy can be entered
+function() {
+page.open(url, function(status) {
+ // use entropy
+ page.evaluate(function() {
+ $(".use-entropy").prop("checked", true).trigger("change");
+ $(".entropy").val("012345").trigger("input");
+ });
+ // check the entropy is shown to be the correct type
+ waitForEntropyFeedback(function() {
+ var entropyText = page.evaluate(function() {
+ return $(".entropy-container").text();
+ });
+ if (entropyText.indexOf("base 6") == -1) {
+ console.log("Base 6 entropy is not detected and presented to user");
+ fail();
+ }
+ next();
+ });
+});
+},
+
+// Base 6 dice entropy can be entered
+function() {
+page.open(url, function(status) {
+ // use entropy
+ page.evaluate(function() {
+ $(".use-entropy").prop("checked", true).trigger("change");
+ $(".entropy").val("123456").trigger("input");
+ });
+ // check the entropy is shown to be the correct type
+ waitForEntropyFeedback(function() {
+ var entropyText = page.evaluate(function() {
+ return $(".entropy-container").text();
+ });
+ if (entropyText.indexOf("dice") == -1) {
+ console.log("Dice entropy is not detected and presented to user");
+ fail();
+ }
+ next();
+ });
+});
+},
+
+// Base 10 entropy can be entered
+function() {
+page.open(url, function(status) {
+ // use entropy
+ page.evaluate(function() {
+ $(".use-entropy").prop("checked", true).trigger("change");
+ $(".entropy").val("789").trigger("input");
+ });
+ // check the entropy is shown to be the correct type
+ waitForEntropyFeedback(function() {
+ var entropyText = page.evaluate(function() {
+ return $(".entropy-container").text();
+ });
+ if (entropyText.indexOf("base 10") == -1) {
+ console.log("Base 10 entropy is not detected and presented to user");
+ fail();
+ }
+ next();
+ });
+});
+},
+
+// Hexadecimal entropy can be entered
+function() {
+page.open(url, function(status) {
+ // use entropy
+ page.evaluate(function() {
+ $(".use-entropy").prop("checked", true).trigger("change");
+ $(".entropy").val("abcdef").trigger("input");
+ });
+ // check the entropy is shown to be the correct type
+ waitForEntropyFeedback(function() {
+ var entropyText = page.evaluate(function() {
+ return $(".entropy-container").text();
+ });
+ if (entropyText.indexOf("hexadecimal") == -1) {
+ console.log("Hexadecimal entropy is not detected and presented to user");
+ fail();
+ }
+ next();
+ });
+});
+},
+
+// Dice entropy value is shown as the converted base 6 value
+function() {
+page.open(url, function(status) {
+ // use entropy
+ page.evaluate(function() {
+ $(".use-entropy").prop("checked", true).trigger("change");
+ $(".entropy").val("123456").trigger("input");
+ });
+ // check the entropy is shown as base 6, not as the original dice value
+ waitForEntropyFeedback(function() {
+ var entropyText = page.evaluate(function() {
+ return $(".entropy-container").text();
+ });
+ if (entropyText.indexOf("012345") == -1) {
+ console.log("Dice entropy is not shown to user as base 6 value");
+ fail();
+ }
+ if (entropyText.indexOf("123456") > -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) {
+ //[ entropy, bits ]
+ var tests = [
+ [ "0000 0000 0000 0000 0000", "20" ],
+ [ "0", "1" ],
+ [ "0000", "4" ],
+ [ "6", "3" ],
+ [ "7", "4" ],
+ [ "8", "4" ],
+ [ "F", "4" ],
+ [ "29", "7" ],
+ [ "0A", "8" ],
+ [ "1A", "8" ], // hex is always multiple of 4 bits of entropy
+ [ "2A", "8" ],
+ [ "4A", "8" ],
+ [ "8A", "8" ],
+ [ "FA", "8" ],
+ [ "000A", "16" ],
+ [ "2220", "11" ],
+ [ "2221", "11" ], // uses dice, so entropy is actually 1110
+ [ "2227", "14" ],
+ [ "222F", "16" ],
+ [ "FFFF", "16" ],
+ ]
+ // use entropy
+ page.evaluate(function(e) {
+ $(".use-entropy").prop("checked", true).trigger("change");
+ });
+ // Run each test
+ var nextTest = function runNextTest(i) {
+ var entropy = tests[i][0];
+ var expected = tests[i][1];
+ // set entropy
+ page.evaluate(function(e) {
+ $(".entropy").val(e).trigger("input");
+ }, entropy);
+ // check the number of bits of entropy is shown
+ waitForEntropyFeedback(function() {
+ var entropyText = page.evaluate(function() {
+ return $(".entropy-error").text();
+ });
+ if (entropyText.indexOf("Have " + expected + " bits of entropy") == -1) {
+ console.log("Accumulated entropy is not shown correctly for " + entropy);
+ console.log(entropyText);
+ fail();
+ }
+ var isLastTest = i == tests.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
+ waitForEntropyFeedback(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();
+ $(".phrase").val("");
+ $(".entropy").val(e).trigger("input");
+ }, test.entropy);
+ if (test.words == 0) {
+ var mnemonic = page.evaluate(function() {
+ return $(".phrase").val();
+ });
+ if (mnemonic.length > 0) {
+ console.log("Mnemonic length for " + test.nextStrength + " strength is not " + test.words);
+ console.log("Mnemonic: " + mnemonic);
+ fail();
+ }
+ var isLastTest = i == tests.length - 1;
+ if (isLastTest) {
+ next();
+ }
+ else {
+ runNextTest(i+1);
+ }
+ }
+ else {
+ waitForGenerate(function() {
+ // check the strength of the current mnemonic
+ var mnemonic = page.evaluate(function() {
+ return $(".phrase").val();
+ });
+ 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();
+ });
+});
+},
+
+// Blank entropy does not generate mnemonic or addresses
+function() {
+page.open(url, function(status) {
+ // use entropy
+ page.evaluate(function() {
+ $(".use-entropy").prop("checked", true).trigger("change");
+ $(".entropy").val("").trigger("input");
+ });
+ waitForFeedback(function() {
+ // check there is no mnemonic
+ var phrase = page.evaluate(function() {
+ return $(".phrase").val();
+ });
+ if (phrase != "") {
+ console.log("Blank entropy does not result in blank mnemonic");
+ console.log("Got: " + phrase);
+ fail();
+ }
+ // check there are no addresses displayed
+ var addresses = page.evaluate(function() {
+ return $(".address").length;
+ });
+ if (addresses != 0) {
+ console.log("Blank entropy does not result in zero addresses");
+ fail();
+ }
+ // Check the feedback says 'blank entropy'
+ var feedback = page.evaluate(function() {
+ return $(".feedback").text();
+ });
+ if (feedback != "Blank entropy") {
+ console.log("Blank entropy does not show feedback message");
+ 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();
+ });
+});
+},
+
+*/
];
projects / perso / Immae / Projets / Cryptomonnaies / BIP39.git / blobdiff