feat: password-gated recovery phrase display for HD wallets (closes #161)

A user who created a wallet in AutistMask and did not write the phrase
down had no way to retrieve it. Adds a "Show recovery phrase" action on
the wallet row in Settings, next to the per-wallet actions that already
live there, mirroring the per-address private key export in structure,
password gate and warning treatment.

The screen displays the secret that owns every address in the wallet, so:

  - Only HD wallets are offered it. walletHasRecoveryPhrase() is an
    allowlist on type "hd", so the key and xprv types — which have no
    phrase at all — are excluded, as is any type added later.
  - Nothing is decrypted and nothing enters the page until
    decryptWithPassword accepts the password. A wrong password produces a
    full-sentence error and leaves the value node empty.
  - Leaving the screen wipes it by any route, not just "Back": views that
    hold a secret register a cleanup with showView() via onViewLeave(),
    which also covers the settings gear.
  - The phrase is never assigned to state, so it cannot be persisted, and
    the view is not in RESTORABLE_VIEWS — reopening the popup lands on
    Home. That set moves to src/popup/restorableViews.js so the exclusion
    can be asserted directly; the popup entry point cannot be required
    outside a browser.
  - The phrase cannot reach the logger: the view does not import
    src/shared/log.js, and the failed-decrypt path reports a fixed
    sentence rather than the caught error.

Tests: unit coverage for the type gate, the RESTORABLE_VIEWS exclusion
and the absence of any logger path; the DOM behaviour is driven against
the real popup in the e2e suite, which is where this repo tests views.

tests/e2e/run.js

@@ -10,6 +10,7 @@
 "use strict";
 
 const {
+    PASSWORD,
     createWallet,
     launch,
     openAddressDetail,
@@ -56,7 +57,11 @@ test("popup loads and reaches the welcome view", async (env) => {
 });
 
 test("wallet creation through the UI reaches the main view", async (env) => {
-    await createWallet(env.page);
+    env.phrase = await createWallet(env.page);
+    assert(
+        env.phrase.split(/\s+/).length >= 12,
+        "wallet creation did not yield a recovery phrase",
+    );
     const addrCount = await env.page
         .locator("#wallet-list .btn-addr-info")
         .count();
@@ -117,6 +122,204 @@ test("transaction detail renders an ERC-20 transfer (#151)", async (env) => {
     assert(dots > 0, "token contract row rendered without its colour dot");
 });
 
+// -------------------------------------------- recovery phrase (#161)
+
+// The gear toggles, so pressing it while Settings is already up leaves it.
+async function openSettings(page) {
+    if (!(await page.isVisible("#view-settings"))) {
+        await page.click("#btn-settings");
+    }
+    await visible(page, "#view-settings");
+}
+
+// Everything the recovery phrase screen is holding, read straight out of
+// the DOM whether or not that screen is the one on top. Reading it while it
+// is hidden is the point: "cleared on leave" means the node is empty, not
+// merely off-screen.
+async function phraseScreenState(page) {
+    return page.evaluate(() => ({
+        value: document.getElementById("show-phrase-value").textContent,
+        error: document.getElementById("show-phrase-flash").textContent,
+        html: document.getElementById("view-show-phrase").innerHTML,
+        resultHidden: document
+            .getElementById("show-phrase-result")
+            .classList.contains("hidden"),
+        viewHidden: document
+            .getElementById("view-show-phrase")
+            .classList.contains("hidden"),
+    }));
+}
+
+async function openPhraseScreen(page) {
+    await openSettings(page);
+    await page.click("#settings-wallet-list .btn-show-phrase");
+    await visible(page, "#view-show-phrase");
+}
+
+async function revealPhrase(page) {
+    await page.fill("#show-phrase-password", PASSWORD);
+    await page.click("#btn-show-phrase-reveal");
+    await visible(page, "#show-phrase-result", 60000);
+}
+
+function assertWiped(st, phrase, where) {
+    assert(st.value === "", "phrase still in the DOM " + where);
+    assert(st.resultHidden, "result section still shown " + where);
+    assert(
+        !st.html.includes(phrase),
+        "the recovery phrase is still somewhere in the screen markup " + where,
+    );
+}
+
+test("only an HD wallet is offered the recovery phrase action (#161)", async (env) => {
+    await openSettings(env.page);
+    const offered = await env.page
+        .locator("#settings-wallet-list .btn-show-phrase")
+        .count();
+    const wallets = await env.page
+        .locator("#settings-wallet-list .btn-delete-wallet")
+        .count();
+    assert(wallets === 1, "expected exactly one wallet row, got " + wallets);
+    assert(
+        offered === 1,
+        "the HD wallet was not offered the recovery phrase action",
+    );
+});
+
+// The other half of the gate, against the real UI: a wallet holding a bare
+// private key has no phrase to show, so no row of it may offer the action.
+// The key is generated here rather than committed — the repo holds no
+// private keys, test ones included.
+test("a key wallet is not offered the recovery phrase action (#161)", async (env) => {
+    const { Wallet } = require("ethers");
+
+    await openSettings(env.page);
+    await env.page.click("#btn-main-add-wallet");
+    await visible(env.page, "#view-add-wallet");
+    await env.page.click("#tab-privkey");
+    await env.page.fill(
+        "#import-private-key",
+        Wallet.createRandom().privateKey,
+    );
+    await env.page.fill("#add-wallet-password", PASSWORD);
+    await env.page.fill("#add-wallet-password-confirm", PASSWORD);
+    await env.page.click("#btn-add-wallet-confirm");
+    await visible(env.page, "#view-main", 60000);
+
+    await openSettings(env.page);
+    const wallets = await env.page
+        .locator("#settings-wallet-list .btn-delete-wallet")
+        .count();
+    const offered = await env.page
+        .locator("#settings-wallet-list .btn-show-phrase")
+        .count();
+    assert(wallets === 2, "expected two wallet rows, got " + wallets);
+    assert(
+        offered === 1,
+        "the key wallet was offered the recovery phrase action",
+    );
+});
+
+test("the recovery phrase screen holds nothing before the password (#161)", async (env) => {
+    await openPhraseScreen(env.page);
+    const st = await phraseScreenState(env.page);
+    assertWiped(st, env.phrase, "before any password was entered");
+    const passwordShown = await env.page.isVisible(
+        "#show-phrase-password-section",
+    );
+    assert(passwordShown, "the password prompt is not shown");
+});
+
+test("a wrong password reveals nothing (#161)", async (env) => {
+    await env.page.fill("#show-phrase-password", "not-the-password");
+    await env.page.click("#btn-show-phrase-reveal");
+    await env.page.waitForFunction(
+        () =>
+            document.getElementById("show-phrase-flash").textContent.length > 0,
+        null,
+        { timeout: 60000 },
+    );
+
+    const st = await phraseScreenState(env.page);
+    assertWiped(st, env.phrase, "after a wrong password");
+    assert(
+        /^[A-Z].*\.$/.test(st.error.trim()),
+        "the wrong-password error is not a full sentence: " +
+            JSON.stringify(st.error),
+    );
+});
+
+test("the correct password reveals the full phrase, and nothing logs it (#161)", async (env) => {
+    const console_ = [];
+    const listener = (msg) => console_.push(msg.text());
+    env.page.on("console", listener);
+    try {
+        await revealPhrase(env.page);
+
+        const st = await phraseScreenState(env.page);
+        assert(
+            st.value === env.phrase,
+            "the displayed phrase is not the wallet's phrase, verbatim",
+        );
+        const promptShown = await env.page.isVisible(
+            "#show-phrase-password-section",
+        );
+        assert(!promptShown, "the password prompt is still shown after unlock");
+
+        // Full Identifiers Policy: shown whole, and copyable.
+        const title = await env.page.getAttribute(
+            "#show-phrase-value",
+            "title",
+        );
+        assert(title === "Click to copy", "the phrase is not click-to-copy");
+
+        const leaked = console_.filter((line) => line.includes(env.phrase));
+        assert(
+            leaked.length === 0,
+            "the recovery phrase reached the console: " +
+                JSON.stringify(leaked),
+        );
+    } finally {
+        env.page.off("console", listener);
+    }
+});
+
+test('"Back" wipes the revealed phrase (#161)', async (env) => {
+    await env.page.click("#btn-show-phrase-back");
+    await visible(env.page, "#view-settings");
+    const st = await phraseScreenState(env.page);
+    assert(st.viewHidden, "the recovery phrase screen is still on top");
+    assertWiped(st, env.phrase, "after Back");
+});
+
+// The settings gear leaves the screen without touching its Back button. A
+// clear wired only to Back would pass the test above and leak here.
+test("leaving by the settings gear wipes it too (#161)", async (env) => {
+    await openPhraseScreen(env.page);
+    await revealPhrase(env.page);
+    await env.page.click("#btn-settings");
+    await visible(env.page, "#view-settings");
+    const st = await phraseScreenState(env.page);
+    assertWiped(st, env.phrase, "after leaving via the settings gear");
+});
+
+// Closing and reopening the page rather than reloading it: that is what
+// the toolbar popup actually does, and the persisted currentView is
+// "show-phrase" at the moment it happens, which is precisely the state
+// RESTORABLE_VIEWS has to refuse.
+test("reopening the popup never lands on the phrase screen (#161)", async (env) => {
+    await openPhraseScreen(env.page);
+    await revealPhrase(env.page);
+
+    await env.page.close();
+    env.page = await openPopup(env.ctx, env.popupUrl);
+    await visible(env.page, "#view-main");
+
+    const st = await phraseScreenState(env.page);
+    assert(st.viewHidden, "the popup reopened onto the recovery phrase screen");
+    assertWiped(st, env.phrase, "after reopening the popup");
+});
+
 // ---------------------------------------------------------------- runner
 
 async function main() {
@@ -154,6 +357,9 @@ async function main() {
         popupUrl: session.popupUrl,
         routeOpts,
         page: null,
+        // The recovery phrase of the wallet created in test 2, so later
+        // tests can assert on the real secret rather than its shape.
+        phrase: null,
     };
 
     // Attribution of collected errors is total. session.errors has no