fix: the first wallet's first address is active as soon as it is added (closes #512)

The popup picked an active address only when it opened, so after the first
wallet was created nothing was active until a reopen: Home had no headline,
and Send and Receive refused. Each of the three import paths on AddWallet now
makes the new wallet's first address active when no address is. The
background already answered sites with that address through its own
fallback, so nothing is broadcast. The address scan stand-in in the popup
test boot now answers in the real scan's shape, which the phrase and xprv
imports read.

Model: opus-5-5

README.md

@@ -1192,16 +1192,7 @@ The core hierarchy is **Wallets → Addresses**:
       of its stored `xpub` by `src/shared/walletDefects.js`, explained in the
       wallet list, and blocked from signing, sending and private-key export. It
       is never deleted or rewritten.
-- An **address** holds ETH and ERC-20 tokens. In an HD or xprv wallet each
-  address record also stores `index`, the derivation index it was made at: 0 for
-  the first address, the index the import scan found it at, or `nextIndex` when
-  "+" added it. An address's `index` and its position in the wallet's list
-  differ once the scan has passed over an unused index or an address has been
-  removed. Sending, site transactions, site signatures and private-key export
-  derive the key at `index`, and refuse it unless it is that address's own key;
-  an HD or xprv address with no valid `index` is refused before anything is
-  derived (`getSignerForAddress()` in `src/shared/wallet.js`). Each refusal is a
-  full sentence naming the address.
+- An **address** holds ETH and ERC-20 tokens.
 - The user can have multiple wallets, each with multiple addresses (HD) or a
   single address (key).
 
@@ -1473,8 +1464,10 @@ view would leave a wallet one click from deletion.
 - **Transitions**:
     - "Import" with a valid entry and a matching password of at least 12
       characters → creates the wallet, clears the navigation stack, and →
-      **Home**. The phrase and xprv modes then scan for further used addresses
-      and report the count as a flash message.
+      **Home**. When no address is active yet, as on the first wallet, the new
+      wallet's first address becomes the active one. The phrase and xprv modes
+      then scan for further used addresses and report the count as a flash
+      message.
     - "Import" with a missing, short or mismatched password → full-sentence
       error on the error line, no screen change
     - "Import" with an invalid entry or a duplicate wallet or address → flash
@@ -1527,9 +1520,6 @@ view would leave a wallet one click from deletion.
       change)
     - "Reveal" (wrong password) → full-sentence error on the error line, nothing
       revealed (no screen change)
-    - "Reveal" (correct password, but this address's key is refused, see Data
-      Model) → full-sentence error saying why, nothing revealed (no screen
-      change)
     - "Back" → previous screen (AddressDetail)
     - Settings gear → **Settings**, whose "Back" goes to AddressDetail: leaving
       drops the address the screen was showing, so it also takes the screen off
@@ -1665,13 +1655,6 @@ view would leave a wallet one click from deletion.
       be signed for another
     - "Sign & Send" (wrong password) → "Wrong password." on the password error
       line, no screen change
-    - "Sign & Send" signs as the From address above, not as whichever address is
-      selected: the two are saved separately, so the popup can reopen onto this
-      screen with another address selected. When the selected wallet does not
-      hold the From address → full-sentence error on the password error line,
-      nothing sent (no screen change)
-    - "Sign & Send" (correct password, but the From address's key is refused,
-      see Data Model) → nothing is signed → **ErrorTx** saying why
     - "Back" → **Send**
 
 #### WaitTx (`wait-tx`)
@@ -2137,9 +2120,6 @@ view would leave a wallet one click from deletion.
       shown, exactly as shown, hands the signed transaction to the background to
       broadcast, then → **WaitTx** in the same popup window
     - "Confirm" (wrong password) → error line, no screen change
-    - "Confirm" (correct password, but the From address's key is refused, see
-      Data Model) → full-sentence error on the error line saying why, nothing
-      signed (no screen change)
     - "Reject" → closes popup (returns rejection to background)
     - Popup window closed without answering → the request is rejected with
       EIP-1193 code 4001
@@ -2204,13 +2184,6 @@ view would leave a wallet one click from deletion.
     - Typed data that states no primary type, or one other than the type it
       would be signed as, or that cannot be read → shown with the error line
       saying so and "Sign" disabled; only "Reject" remains
-    - Typed data whose message leaves out a field its type declares, at any
-      level of nesting, or gives a `bool` field a value other than `true` or
-      `false` → shown with the error line naming the field and "Sign" disabled;
-      only "Reject" remains. ethers signs a `bool` by whether its value is
-      truthy, so the string `"false"` would be signed as true and a field left
-      out as false. The background refuses such a signature too and answers the
-      site with the same sentence
     - Typed data whose domain `chainId` names a chain other than the active
       network's → shown with the error line naming both chain ids and "Sign"
       disabled; only "Reject" remains. EIP-712 asks for this, because the

src/background/index.js

@@ -22,8 +22,6 @@ const { debugFetch, log } = require("../shared/log");
 const {
     verifySignedTx,
     verifySignature,
-    signedPrimaryType,
-    typedDataMessageRefusal,
     typedDataChainRefusal,
     failureIsRetryable,
     describeTxFailure,
@@ -1789,27 +1787,18 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
                     signature,
                     approval.approvedFrom,
                 );
-                // The sign screen refuses typed data whose message ethers
-                // would sign differently from how it is shown, or whose
-                // domain names another chain. A signature for it that arrives
-                // anyway is refused here, against the network active now.
+                // The sign screen refuses typed data whose domain names
+                // another chain. A signature for it that arrives anyway is
+                // refused here, against the network active now.
                 const sp = approval.signParams;
                 if (
                     sp.method === "eth_signTypedData_v4" ||
                     sp.method === "eth_signTypedData"
                 ) {
-                    const data = JSON.parse(sp.typedData);
-                    const refusal =
-                        typedDataMessageRefusal(
-                            data.types,
-                            signedPrimaryType(data.types),
-                            data.message,
-                            "",
-                        ) ||
-                        typedDataChainRefusal(
-                            data.domain,
-                            networkById(s.networkId),
-                        );
+                    const refusal = typedDataChainRefusal(
+                        JSON.parse(sp.typedData).domain,
+                        networkById(s.networkId),
+                    );
                     if (refusal) throw new ApprovalMismatchError(refusal);
                 }
                 settleApproval(msg.id, { signature }, { holdsClaim: true });

src/popup/views/addWallet.js

@@ -184,16 +184,14 @@ async function importMnemonic(ctx) {
         encryptedSecret: encrypted,
         nextIndex: 1,
         addresses: [
-            {
-                address: firstAddress,
-                index: 0,
-                balance: "0.0000",
-                tokenBalances: [],
-            },
+            { address: firstAddress, balance: "0.0000", tokenBalances: [] },
         ],
     };
     state.wallets.push(wallet);
     state.hasWallet = true;
+    if (state.activeAddress === null) {
+        state.activeAddress = firstAddress;
+    }
     await saveState();
     clearViewStack();
     ctx.renderWalletList();
@@ -210,7 +208,6 @@ async function importMnemonic(ctx) {
     if (scan.addresses.length > 1) {
         wallet.addresses = scan.addresses.map((a) => ({
             address: a.address,
-            index: a.index,
             balance: "0.0000",
             tokenBalances: [],
         }));
@@ -254,6 +251,9 @@ async function importPrivateKey(ctx) {
         addresses: [{ address: addr, balance: "0.0000", tokenBalances: [] }],
     });
     state.hasWallet = true;
+    if (state.activeAddress === null) {
+        state.activeAddress = addr;
+    }
     await saveState();
     clearViewStack();
     ctx.renderWalletList();
@@ -305,16 +305,14 @@ async function importXprvKey(ctx) {
         encryptedSecret: encrypted,
         nextIndex: 1,
         addresses: [
-            {
-                address: firstAddress,
-                index: 0,
-                balance: "0.0000",
-                tokenBalances: [],
-            },
+            { address: firstAddress, balance: "0.0000", tokenBalances: [] },
         ],
     };
     state.wallets.push(wallet);
     state.hasWallet = true;
+    if (state.activeAddress === null) {
+        state.activeAddress = firstAddress;
+    }
     await saveState();
     clearViewStack();
     ctx.renderWalletList();
@@ -331,7 +329,6 @@ async function importXprvKey(ctx) {
     if (scan.addresses.length > 1) {
         wallet.addresses = scan.addresses.map((a) => ({
             address: a.address,
-            index: a.index,
             balance: "0.0000",
             tokenBalances: [],
         }));

src/popup/views/addressDetail.js

@@ -266,7 +266,7 @@ function init(_ctx) {
         // This address's private key can be derived from the stored key,
         // but export goes through getSignerForAddress, which refuses a key
         // that is not a master key. Without this the export screen would
-        // take a password and then refuse.
+        // take a password and then report that refusal as a wrong password.
         const defect = selectedWalletDefect();
         if (defect) {
             showFlash(defect.shortMessage);

src/popup/views/approval.js

@@ -27,6 +27,7 @@ const {
     Interface,
     MaxUint256,
     toUtf8String,
+    TypedDataEncoder,
 } = require("ethers");
 const { getPrice, formatUsd } = require("../../shared/prices");
 const { ERC20_ABI } = require("../../shared/constants");
@@ -47,8 +48,6 @@ const { getSignerForAddress } = require("../../shared/wallet");
 const { walletDefect } = require("../../shared/walletDefects");
 const {
     describeSigningFailure,
-    signedPrimaryType,
-    typedDataMessageRefusal,
     typedDataChainRefusal,
 } = require("../../shared/approvalVerify");
 const txStatus = require("./txStatus");
@@ -433,12 +432,22 @@ function markInvisibleCharacters(text) {
         );
 }
 
+// The type ethers will sign typed data as. ethers does not read the page's
+// `primaryType`: it takes the one struct in `types` that no other struct
+// refers to. Throws when the types name no such single struct, which ethers
+// would refuse to sign as well.
+function signedPrimaryType(types) {
+    const structs = { ...types };
+    // ethers derives EIP712Domain itself and rejects it as an input.
+    delete structs.EIP712Domain;
+    return TypedDataEncoder.getPrimaryType(structs);
+}
+
 // Why a signature request cannot be signed, as a sentence for the error line,
 // or null when it can. Only typed data is refused: the `primaryType` the page
 // states has to be the type ethers will sign, or this screen would name one
-// message while another is signed. Its message has to hold every declared
-// field, with each `bool` true or false, and its domain may name no chain but
-// the active network's.
+// message while another is signed. Its domain may name no chain but the active
+// network's.
 function typedDataRefusal(sp) {
     if (sp.method === "personal_sign" || sp.method === "eth_sign") return null;
     let data;
@@ -461,10 +470,7 @@ function typedDataRefusal(sp) {
             ", so it cannot be signed."
         );
     }
-    return (
-        typedDataMessageRefusal(data.types, signed, data.message, "") ||
-        typedDataChainRefusal(data.domain, currentNetwork())
-    );
+    return typedDataChainRefusal(data.domain, currentNetwork());
 }
 
 // The largest amount a Permit2 allowance can hold, a uint160. Permit2 treats
@@ -907,15 +913,15 @@ function gateOnWalletDefect(errorId, buttonId, address) {
     return true;
 }
 
-// Locate the wallet and the stored address record owning an address. Returns
-// null when no wallet holds it. Approvals look up the address they were raised
-// for, not whichever address is active now: the approval named one account,
-// and signing with another is what verification refuses.
+// Locate the wallet and the address index owning an address. Returns null when
+// no wallet holds it. Approvals look up the address they were raised for, not
+// whichever address is active now: the approval named one account, and signing
+// with another is what verification refuses.
 function findWalletFor(address) {
     for (const wallet of state.wallets) {
         for (let i = 0; i < wallet.addresses.length; i++) {
             if (wallet.addresses[i].address === address) {
-                return { wallet, addr: wallet.addresses[i] };
+                return { wallet, addrIndex: i };
             }
         }
     }
@@ -1042,7 +1048,7 @@ function init(_ctx) {
         try {
             const signer = getSignerForAddress(
                 active.wallet,
-                active.addr,
+                active.addrIndex,
                 decryptedSecret,
             );
             // Sign the approved transaction exactly as it was displayed. The
@@ -1170,7 +1176,7 @@ function init(_ctx) {
         try {
             const signer = getSignerForAddress(
                 active.wallet,
-                active.addr,
+                active.addrIndex,
                 decryptedSecret,
             );
             const sp = pendingSignParams;

src/popup/views/confirmTx.js

@@ -567,19 +567,6 @@ function init(_ctx) {
             return;
         }
 
-        // Sign as the From address this screen shows. The selection is saved
-        // apart from this screen, so the popup can reopen onto it with another
-        // address selected.
-        const addr = wallet.addresses.find((a) => a.address === pendingTx.from);
-        if (!addr) {
-            showError(
-                "confirm-tx-password-error",
-                "The selected wallet does not hold the From address above, " +
-                    "so nothing was sent. Please go back and send again.",
-            );
-            return;
-        }
-
         const password = $("confirm-tx-password").value;
         if (!password) {
             showError(
@@ -610,7 +597,11 @@ function init(_ctx) {
 
         let tx;
         try {
-            const signer = getSignerForAddress(wallet, addr, decryptedSecret);
+            const signer = getSignerForAddress(
+                wallet,
+                state.selectedAddress,
+                decryptedSecret,
+            );
             const provider = getProvider(state.rpcUrl, state.networkId);
             const connectedSigner = signer.connect(provider);
 

src/popup/views/exportPrivkey.js

@@ -135,18 +135,7 @@ async function reveal() {
         // decrypt ran, the wipe has already happened, so the key is not
         // even derived, let alone written.
         if (!isCurrentReveal(generation)) return;
-        let signer;
-        try {
-            signer = getSignerForAddress(
-                wallet,
-                wallet.addresses[addressIndex],
-                secret,
-            );
-        } catch (e) {
-            // The password was right; it is the key that was refused.
-            showError("export-privkey-password-error", e.message);
-            return;
-        }
+        const signer = getSignerForAddress(wallet, addressIndex, secret);
         $("export-privkey-password").value = "";
         $("export-privkey-password-section").classList.add("hidden");
         $("export-privkey-value").textContent = signer.privateKey;

src/popup/views/home.js

@@ -354,7 +354,6 @@ function render(ctx) {
             );
             wallet.addresses.push({
                 address: newAddr,
-                index: wallet.nextIndex,
                 balance: "0.0000",
                 tokenBalances: [],
             });

src/shared/approvalVerify.js

@@ -56,7 +56,6 @@ const {
     getBigInt,
     getBytes,
     toQuantity,
-    TypedDataEncoder,
     verifyMessage,
     verifyTypedData,
 } = require("ethers");
@@ -637,63 +636,6 @@ function verifySignature(signParams, signature, expectedFrom) {
     return recovered;
 }
 
-// The type ethers will sign typed data as. ethers does not read the page's
-// `primaryType`: it takes the one struct in `types` that no other struct
-// refers to. Throws when the types name no such single struct, which ethers
-// would refuse to sign as well.
-function signedPrimaryType(types) {
-    const structs = { ...types };
-    // ethers derives EIP712Domain itself and rejects it as an input.
-    delete structs.EIP712Domain;
-    return TypedDataEncoder.getPrimaryType(structs);
-}
-
-// Why a typed data message cannot be signed as the screen shows it, as a
-// sentence, or null when it can. ethers signs a `bool` field by whether its
-// value is truthy, so the string "false" is signed as true and a field left
-// out as false. Each field that `type` declares, at every level of nesting,
-// must be one of the value's own keys, and each `bool` must be true or false.
-// Called with the type ethers signs, the message, and a `path` of "".
-function typedDataMessageRefusal(types, type, value, path) {
-    const itemType = type.replace(/\[\d*\]$/, "");
-    if (itemType !== type) {
-        // ethers refuses to sign a list field that is not a list.
-        if (!Array.isArray(value)) return null;
-        for (let i = 0; i < value.length; i++) {
-            const refusal = typedDataMessageRefusal(
-                types,
-                itemType,
-                value[i],
-                `${path}[${i}]`,
-            );
-            if (refusal) return refusal;
-        }
-        return null;
-    }
-    if (type === "bool" && value !== true && value !== false) {
-        return `The field "${path}" is not true or false, so this typed data cannot be signed.`;
-    }
-    for (const field of types[type] || []) {
-        const at = path ? `${path}.${field.name}` : field.name;
-        // An own key only: a plain lookup of `constructor` finds a function.
-        const present =
-            value !== null &&
-            typeof value === "object" &&
-            Object.prototype.hasOwnProperty.call(value, field.name);
-        if (!present) {
-            return `The field "${at}" is missing from the message, so this typed data cannot be signed.`;
-        }
-        const refusal = typedDataMessageRefusal(
-            types,
-            field.type,
-            value[field.name],
-            at,
-        );
-        if (refusal) return refusal;
-    }
-    return null;
-}
-
 // Why typed data cannot be signed while `network` is the active network, as a
 // sentence, or null when it can. EIP-712 has a wallet refuse typed data whose
 // domain names another chain, because the signature is valid on that chain.
@@ -882,8 +824,6 @@ function describeSigningFailure(response, fallbackMessage) {
 module.exports = {
     verifySignedTx,
     verifySignature,
-    signedPrimaryType,
-    typedDataMessageRefusal,
     typedDataChainRefusal,
     assertNoForbiddenFields,
     assertNothingUnchecked,

src/shared/wallet.js

@@ -110,33 +110,16 @@ function addressFromPrivateKey(key) {
     return w.address;
 }
 
-// The signer for `addr`, one of the wallet's stored address records. An HD or
-// xprv address is derived at its own `index`, never at its position in the
-// wallet's list: the two differ once an import scan passes over an unused
-// index, or once an address that is not the last is removed. An HD or xprv
-// record without a valid `index` is refused before anything is derived.
-// Whatever the wallet type, the key is refused unless it is the key of
-// `addr.address`.
-function getSignerForAddress(walletData, addr, decryptedSecret) {
-    if (
-        (walletData.type === "hd" || walletData.type === "xprv") &&
-        !(Number.isInteger(addr.index) && addr.index >= 0)
-    ) {
-        throw new Error(
-            "No derivation index is stored for " +
-                addr.address +
-                ", so its key cannot be derived.",
-        );
-    }
-    let signer;
+function getSignerForAddress(walletData, addrIndex, decryptedSecret) {
     if (walletData.type === "hd") {
         const node = HDNodeWallet.fromPhrase(
             decryptedSecret,
             "",
             BIP44_ETH_PATH,
         );
-        signer = node.deriveChild(addr.index);
-    } else if (walletData.type === "xprv") {
+        return node.deriveChild(addrIndex);
+    }
+    if (walletData.type === "xprv") {
         // Checked here rather than through masterXprvOrThrow so the message
         // fits the situation: nobody is importing anything at signing time,
         // and this wallet is already in storage. src/shared/walletDefects.js
@@ -154,18 +137,9 @@ function getSignerForAddress(walletData, addr, decryptedSecret) {
                     "is not a master key, so it cannot sign.",
             );
         }
-        signer = node.derivePath(BIP44_ETH_PATH).deriveChild(addr.index);
-    } else {
-        signer = new Wallet(decryptedSecret);
+        return node.derivePath(BIP44_ETH_PATH).deriveChild(addrIndex);
     }
-    if (signer.address.toLowerCase() !== addr.address.toLowerCase()) {
-        throw new Error(
-            "The key this wallet holds for " +
-                addr.address +
-                " belongs to a different address, so it was not used.",
-        );
-    }
-    return signer;
+    return new Wallet(decryptedSecret);
 }
 
 function isValidMnemonic(mnemonic) {

tests/addressKey.test.js

@@ -1,490 +0,0 @@
-// Sending, a site's transaction and signature requests and private key export
-// each use the key of the address they name: the key at the index that address
-// was derived at, not the one at its position in the wallet's list. The two
-// differ after an import whose scan passed over an unused index, and after an
-// address that is not the last is removed
-// (https://git.eeqj.de/sneak/AutistMask/issues/510). A send is signed by the
-// From address its confirmation screen shows, whichever address is selected.
-//
-// Driven through the real import, "+" button, address removal, confirmation
-// screen, transaction and signature approval screens and export screen, with
-// the node, the vault and the DOM stubbed.
-
-"use strict";
-
-// The addresses the stub node reports a balance for, and the signed
-// transactions it was handed.
-const mockNode = { funded: new Set(), broadcast: [] };
-
-jest.mock("ethers", () => {
-    const actual = jest.requireActual("ethers");
-    class StubProvider {
-        async getBalance(address) {
-            return mockNode.funded.has(address) ? 1n : 0n;
-        }
-        async getTransactionCount() {
-            return 0;
-        }
-        async estimateGas() {
-            return 21000n;
-        }
-        async getFeeData() {
-            return {
-                maxFeePerGas: 20000000000n,
-                maxPriorityFeePerGas: 1000000000n,
-                gasPrice: 10000000000n,
-            };
-        }
-        async getNetwork() {
-            return { chainId: 1n };
-        }
-        async getCode() {
-            return "0x";
-        }
-        async lookupAddress() {
-            return null;
-        }
-        async broadcastTransaction(signed) {
-            mockNode.broadcast.push(signed);
-            return { hash: "0x" + "ab".repeat(32) };
-        }
-    }
-    return { ...actual, JsonRpcProvider: StubProvider };
-});
-
-// No password is hashed: what the wallet stores is the phrase itself.
-jest.mock("../src/shared/vault", () => ({
-    encryptWithPassword: async (secret) => secret,
-    decryptWithPassword: async (secret) => secret,
-}));
-
-// The wait screen polls for a receipt; these tests stop at the broadcast.
-jest.mock("../src/popup/views/txStatus", () => ({
-    showWait: jest.fn(),
-    showError: jest.fn(),
-}));
-
-jest.mock("ethereum-blockies-base64", () => () => "data:image/png;base64,x");
-
-global.fetch = jest.fn(() => {
-    throw new Error("tests must not perform network requests");
-});
-
-const {
-    HDNodeWallet,
-    Mnemonic,
-    Transaction,
-    getBytes,
-    verifyMessage,
-} = require("ethers");
-
-// Publicly known development phrase; never fund it.
-const PHRASE = "test test test test test test test test test test test junk";
-// PHRASE's master extended private key, as the xprv import takes it.
-const XPRV = HDNodeWallet.fromSeed(
-    Mnemonic.fromPhrase(PHRASE).computeSeed(),
-).extendedKey;
-const PASSWORD = "correct horse battery staple";
-const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
-// "Hello", as the hex a page sends.
-const MESSAGE = "0x48656c6c6f";
-
-// The address and key at derivation index `index` of PHRASE, worked out with
-// ethers directly rather than through the wallet's own code.
-function derived(index) {
-    return HDNodeWallet.fromPhrase(PHRASE, "", "m/44'/60'/0'/0/" + index);
-}
-
-// ------------------------------------------------------------ DOM stub
-
-function makeElement(id) {
-    const classes = new Set();
-    const el = {
-        id,
-        textContent: "",
-        title: "",
-        value: "",
-        innerHTML: "",
-        disabled: false,
-        style: {},
-        dataset: {},
-        listeners: {},
-        classList: {
-            add: (...names) => names.forEach((n) => classes.add(n)),
-            remove: (...names) => names.forEach((n) => classes.delete(n)),
-            contains: (n) => classes.has(n),
-            toggle: (n, force) => {
-                const on = force === undefined ? !classes.has(n) : force;
-                if (on) classes.add(n);
-                else classes.delete(n);
-                return on;
-            },
-        },
-        addEventListener: (name, fn) => {
-            el.listeners[name] = el.listeners[name] || [];
-            el.listeners[name].push(fn);
-        },
-        querySelectorAll: () => [],
-        appendChild: () => {},
-    };
-    // Views reach for .parentElement to hide whole sections.
-    Object.defineProperty(el, "parentElement", {
-        get: () => node(id + "-parent"),
-    });
-    return el;
-}
-
-function makeDocument() {
-    const els = new Map();
-    return {
-        getElementById(id) {
-            // The debug banner is created on demand by helpers.js; absent
-            // is the state a non-debug, non-testnet popup is in.
-            if (id === "debug-banner") return null;
-            if (!els.has(id)) els.set(id, makeElement(id));
-            return els.get(id);
-        },
-        createElement: () => makeElement("created"),
-        addEventListener: () => {},
-        body: { prepend: () => {} },
-    };
-}
-
-function node(id) {
-    return globalThis.document.getElementById(id);
-}
-
-function click(element) {
-    const event = { stopPropagation: () => {} };
-    return Promise.all((element.listeners.click || []).map((fn) => fn(event)));
-}
-
-// show() starts the fee estimate without awaiting it; this lets it settle.
-async function settle() {
-    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
-}
-
-// ------------------------------------------------------------ harness
-
-globalThis.chrome = {
-    storage: { local: { get: async () => ({}), set: async () => {} } },
-};
-
-const { state } = require("../src/shared/state");
-const { removeAddressFromState } = require("../src/shared/walletDelete");
-const addWallet = require("../src/popup/views/addWallet");
-const home = require("../src/popup/views/home");
-const confirmTx = require("../src/popup/views/confirmTx");
-const approval = require("../src/popup/views/approval");
-const exportPrivkey = require("../src/popup/views/exportPrivkey");
-const txStatus = require("../src/popup/views/txStatus");
-
-// What the background answers when the approval window asks which approval it
-// was opened for, and every message the popup sent it.
-let approvalDetails;
-let sent;
-
-// The "+" button of the wallet list's last render. Each render attaches the
-// handler to the buttons it drew, as the browser's fresh list would have.
-let plusButton;
-
-beforeEach(() => {
-    approvalDetails = null;
-    sent = [];
-    mockNode.broadcast = [];
-    globalThis.document = makeDocument();
-    globalThis.window = { close: () => {} };
-    globalThis.chrome = {
-        storage: { local: { get: async () => ({}), set: async () => {} } },
-        runtime: {
-            connect: () => ({ postMessage: () => {} }),
-            sendMessage: (msg, reply) => {
-                sent.push(msg);
-                if (!reply) return;
-                reply(
-                    msg.type === "AUTISTMASK_GET_APPROVAL"
-                        ? approvalDetails
-                        : null,
-                );
-            },
-        },
-    };
-    node("wallet-list").querySelectorAll = (selector) => {
-        if (selector !== ".btn-add-address") return [];
-        plusButton = makeElement("btn-add-address");
-        plusButton.dataset.wallet = "0";
-        return [plusButton];
-    };
-    // The explorer and price lookups these screens start fail offline, and
-    // say so; that is not under test.
-    for (const method of ["log", "warn", "error"]) {
-        jest.spyOn(console, method).mockImplementation(() => {});
-    }
-    txStatus.showError.mockClear();
-
-    state.wallets = [];
-    state.rpcUrl = "https://rpc.example.invalid";
-    state.networkId = "mainnet";
-    state.viewStack = [];
-    state.currentView = "main";
-
-    addWallet.init({
-        renderWalletList: () => {},
-        doRefreshAndRender: () => {},
-        pageClosed: new AbortController().signal,
-    });
-    confirmTx.init({});
-    approval.init({});
-    exportPrivkey.init();
-});
-
-afterEach(() => {
-    jest.restoreAllMocks();
-});
-
-// Import PHRASE on the add-wallet screen, with the stub node reporting a
-// balance at each of `fundedIndices`, and wait for the address scan.
-async function importPhrase(fundedIndices) {
-    mockNode.funded = new Set(fundedIndices.map((i) => derived(i).address));
-    await click(node("tab-mnemonic"));
-    node("wallet-mnemonic").value = PHRASE;
-    node("add-wallet-password").value = PASSWORD;
-    node("add-wallet-password-confirm").value = PASSWORD;
-    await click(node("btn-add-wallet-confirm"));
-}
-
-// The same, importing XPRV on the add-wallet screen's xprv tab.
-async function importXprv(fundedIndices) {
-    mockNode.funded = new Set(fundedIndices.map((i) => derived(i).address));
-    await click(node("tab-xprv"));
-    node("import-xprv-key").value = XPRV;
-    node("add-wallet-password").value = PASSWORD;
-    node("add-wallet-password-confirm").value = PASSWORD;
-    await click(node("btn-add-wallet-confirm"));
-}
-
-// Press the wallet's "+" button on Home.
-async function addAddress() {
-    home.render({
-        doRefreshAndRender: () => {},
-        pageClosed: new AbortController().signal,
-    });
-    await click(plusButton);
-}
-
-// The key the export screen reveals for the address at `position`.
-async function exportedKey(position) {
-    exportPrivkey.show(0, position);
-    node("export-privkey-password").value = PASSWORD;
-    await click(node("btn-export-privkey-confirm"));
-    return node("export-privkey-value").textContent;
-}
-
-// Confirm a send whose From line shows `from`, with the address at position
-// `selected` selected; resolves to the signed transaction the node was handed,
-// or undefined when none was.
-async function confirmSend(from, selected) {
-    state.selectedWallet = 0;
-    state.selectedAddress = selected;
-    confirmTx.show({
-        from,
-        to: RECIPIENT,
-        amount: "0.5",
-        token: "ETH",
-        balance: "1.0",
-    });
-    await settle();
-    node("confirm-tx-password").value = PASSWORD;
-    await click(node("btn-confirm-send"));
-    return mockNode.broadcast.pop();
-}
-
-// Send from the address at `position`, with that address selected, as the Send
-// button leaves it.
-function sendFrom(position) {
-    return confirmSend(state.wallets[0].addresses[position].address, position);
-}
-
-// A site asks the address at `position` to sign MESSAGE; resolves to the
-// response the approval window sent the background.
-async function signFor(position) {
-    const address = state.wallets[0].addresses[position].address;
-    approvalDetails = {
-        type: "sign",
-        origin: "https://dapp.example",
-        isPhishingDomain: false,
-        approvedFrom: address,
-        signParams: {
-            method: "personal_sign",
-            message: MESSAGE,
-            from: address,
-        },
-    };
-    await approval.show(1);
-    node("approve-sign-password").value = PASSWORD;
-    await click(node("btn-approve-sign"));
-    return sent.find((msg) => msg.type === "AUTISTMASK_SIGN_RESPONSE");
-}
-
-// A site asks the address at `position` to send RECIPIENT a transaction of no
-// value; resolves to the response the approval window sent the background.
-async function transactFor(position) {
-    const address = state.wallets[0].addresses[position].address;
-    approvalDetails = {
-        type: "tx",
-        origin: "https://dapp.example",
-        isPhishingDomain: false,
-        approvedFrom: address,
-        approvedTx: {
-            type: 2,
-            from: address,
-            chainId: "0x1",
-            nonce: "0x0",
-            gasLimit: "0x5208",
-            maxPriorityFeePerGas: "0x3b9aca00",
-            maxFeePerGas: "0x77359400",
-            to: RECIPIENT,
-            value: "0x0",
-            data: "0x",
-            accessList: [],
-        },
-    };
-    await approval.show(1);
-    node("approve-tx-password").value = PASSWORD;
-    await click(node("btn-approve-tx"));
-    return sent.find((msg) => msg.type === "AUTISTMASK_TX_RESPONSE");
-}
-
-describe.each([
-    [
-        "a recovery phrase import whose scan found only the first address",
-        async () => {
-            await importPhrase([0]);
-        },
-        // The address the import stores before its scan.
-        { position: 0, index: 0 },
-    ],
-    [
-        "an xprv import whose scan found only the first address",
-        async () => {
-            await importXprv([0]);
-        },
-        { position: 0, index: 0 },
-    ],
-    [
-        "an import whose scan passed over index 3",
-        async () => {
-            await importPhrase([0, 1, 2, 4]);
-        },
-        // Address 4 on Home, derived at index 4.
-        { position: 3, index: 4 },
-    ],
-    [
-        "an xprv import whose scan passed over index 3",
-        async () => {
-            await importXprv([0, 1, 2, 4]);
-        },
-        { position: 3, index: 4 },
-    ],
-    [
-        "removing the middle one of three addresses",
-        async () => {
-            await importPhrase([0]);
-            await addAddress();
-            await addAddress();
-            removeAddressFromState(state, 0, 1);
-        },
-        // Address 2 on Home after the removal, derived at index 2.
-        { position: 1, index: 2 },
-    ],
-])("after %s", (_name, setUp, { position, index }) => {
-    beforeEach(setUp);
-
-    test("the wallet lists the address derived at that index there", () => {
-        expect(state.wallets[0].addresses[position].address).toBe(
-            derived(index).address,
-        );
-    });
-
-    test("export reveals that address's key", async () => {
-        expect(await exportedKey(position)).toBe(derived(index).privateKey);
-    });
-
-    test("a send is signed by that address", async () => {
-        const signed = await sendFrom(position);
-        expect(Transaction.from(signed).from).toBe(derived(index).address);
-    });
-
-    test("a site's signature is made by that address", async () => {
-        const response = await signFor(position);
-        expect(verifyMessage(getBytes(MESSAGE), response.signature)).toBe(
-            derived(index).address,
-        );
-    });
-
-    test("a site's transaction is signed by that address", async () => {
-        const response = await transactFor(position);
-        expect(Transaction.from(response.rawSignedTx).from).toBe(
-            derived(index).address,
-        );
-    });
-});
-
-// The selection and the confirmation screen are saved apart, so the popup can
-// reopen onto the screen with another address selected than its From line
-// shows.
-describe("a confirmation screen whose From is not the selected address", () => {
-    beforeEach(async () => {
-        await importPhrase([0, 1]);
-    });
-
-    test("the send is signed by the From address shown", async () => {
-        const signed = await confirmSend(derived(1).address, 0);
-        expect(Transaction.from(signed).from).toBe(derived(1).address);
-    });
-
-    test("nothing is sent when the selected wallet does not hold it", async () => {
-        expect(await confirmSend(derived(5).address, 0)).toBeUndefined();
-        expect(node("confirm-tx-password-error").textContent).toBe(
-            "The selected wallet does not hold the From address above, " +
-                "so nothing was sent. Please go back and send again.",
-        );
-    });
-});
-
-describe("an address whose stored index derives a different address", () => {
-    function refusal() {
-        return (
-            "The key this wallet holds for " +
-            derived(0).address +
-            " belongs to a different address, so it was not used."
-        );
-    }
-
-    beforeEach(async () => {
-        await importPhrase([0]);
-        state.wallets[0].addresses[0].index = 1;
-    });
-
-    test("export reveals nothing and says why", async () => {
-        expect(await exportedKey(0)).toBe("");
-        expect(node("export-privkey-password-error").textContent).toBe(
-            refusal(),
-        );
-    });
-
-    test("nothing is sent", async () => {
-        expect(await sendFrom(0)).toBeUndefined();
-        expect(txStatus.showError).toHaveBeenCalledWith(
-            expect.anything(),
-            null,
-            refusal(),
-        );
-    });
-
-    test("nothing is signed", async () => {
-        const response = await signFor(0);
-        expect(response.signature).toBeUndefined();
-        expect(response.error).toBe(refusal());
-    });
-});

tests/approvalNonce.test.js

@@ -136,9 +136,7 @@ async function openTxApproval(approvedTx) {
             xpub: "xpub-wallet-1",
             encryptedSecret: "encrypted-secret-1",
             nextIndex: 1,
-            addresses: [
-                { address: FROM, index: 0, balance: "0", tokenBalances: [] },
-            ],
+            addresses: [{ address: FROM, balance: "0", tokenBalances: [] }],
         },
     ];
     approval.init({});

tests/approvalVerify.test.js

@@ -1454,11 +1454,7 @@ describe("background population to popup signing to verification", () => {
 
     // What the popup does with it: signs it as given, populating nothing.
     async function popupSigns(approvedTx) {
-        const localSigner = getSignerForAddress(
-            walletData,
-            { address: signer.address },
-            SIGNER_KEY,
-        );
+        const localSigner = getSignerForAddress(walletData, 0, SIGNER_KEY);
         return localSigner.signTransaction({ ...approvedTx });
     }
 
@@ -1553,11 +1549,7 @@ describe("background population to popup signing to verification", () => {
     // address the user has switched to.
     test("the approved from stops the popup signing with another key", async () => {
         const approvedTx = await backgroundPrepares(TX_PARAMS);
-        const otherSigner = getSignerForAddress(
-            walletData,
-            { address: other.address },
-            OTHER_KEY,
-        );
+        const otherSigner = getSignerForAddress(walletData, 0, OTHER_KEY);
         await expect(
             otherSigner.signTransaction({ ...approvedTx }),
         ).rejects.toThrow(/from address mismatch/);

tests/backgroundApproval.test.js

@@ -384,13 +384,13 @@ function loadBackground(options) {
 
     // The same through eth_signTypedData_v4, whose params name the address
     // first and the typed data second.
-    function requestTypedData(typedData = TYPED_DATA) {
+    function requestTypedData() {
         let rpcResult = null;
         messageListener(
             {
                 type: "AUTISTMASK_RPC",
                 method: "eth_signTypedData_v4",
-                params: [signer.address, typedData],
+                params: [signer.address, TYPED_DATA],
             },
             { origin: ORIGIN },
             (r) => {
@@ -1494,8 +1494,8 @@ describe("what the approval is verified against", () => {
     // screen; a signature for it that reaches the background anyway is not
     // handed to the page (https://git.eeqj.de/sneak/AutistMask/issues/519).
     // TYPED_DATA names mainnet.
-    async function answerTypedData(bg, pending, typedData = TYPED_DATA) {
-        const { domain, types, message } = JSON.parse(typedData);
+    async function answerTypedData(bg, pending) {
+        const { domain, types, message } = JSON.parse(TYPED_DATA);
         delete types.EIP712Domain;
         const signature = await signer.signTypedData(domain, types, message);
         const answer = bg.send(
@@ -1539,42 +1539,6 @@ describe("what the approval is verified against", () => {
         expect(pending.result()).toEqual({ error: { message: refusal } });
     });
 
-    // ethers signs a `bool` field sent as the string "false" as true, and one
-    // left out as false. The sign screen refuses both; a signature for either
-    // that reaches the background anyway is not handed to the page
-    // (https://git.eeqj.de/sneak/AutistMask/issues/552).
-    test.each([
-        [
-            '"false"',
-            "false",
-            'The field "approved" is not true or false, so this typed data cannot be signed.',
-        ],
-        [
-            "left out",
-            undefined,
-            'The field "approved" is missing from the message, so this typed data cannot be signed.',
-        ],
-    ])(
-        "typed data with a bool %s is refused, not handed back",
-        async (_, approved, refusal) => {
-            const data = JSON.parse(TYPED_DATA);
-            data.types.Note.push({ name: "approved", type: "bool" });
-            data.message.approved = approved;
-            const typedData = JSON.stringify(data);
-            const bg = loadBackground();
-            const pending = bg.requestTypedData(typedData);
-            await settle();
-
-            const { answer } = await answerTypedData(bg, pending, typedData);
-
-            expect(answer.sendResponse).toHaveBeenCalledWith({
-                error: refusal,
-                retryable: false,
-            });
-            expect(pending.result()).toEqual({ error: { message: refusal } });
-        },
-    );
-
     test("a sign request from another address raises no approval at all", async () => {
         const bg = loadBackground();
         const pending = bg.requestSign(other.address);

tests/firstWalletActiveAddress.test.js

@@ -0,0 +1,69 @@
+// Adding the first wallet left no address active until the popup was reopened,
+// so Send and Receive on Home only said "No active address selected."
+// (https://git.eeqj.de/sneak/AutistMask/issues/512). Each test boots a fresh
+// install, adds the first wallet through one of the three import tabs, and
+// opens Receive from Home in the same popup.
+
+const { HDNodeWallet, Mnemonic, Wallet } = require("ethers");
+
+const { bootPopup, cleanupPopup } = require("./support/popupBoot");
+
+const PHRASE =
+    "abandon abandon abandon abandon abandon abandon " +
+    "abandon abandon abandon abandon abandon about";
+const PRIVATE_KEY = "0x" + "11".repeat(32);
+// The master key of PHRASE, so its first address is the phrase's.
+const XPRV = HDNodeWallet.fromSeed(
+    Mnemonic.fromPhrase(PHRASE).computeSeed(),
+).extendedKey;
+const PASSWORD = "correct horse battery staple";
+
+const PHRASE_ADDRESS = HDNodeWallet.fromPhrase(PHRASE).address;
+
+const TABS = [
+    {
+        tab: "tab-mnemonic",
+        field: "wallet-mnemonic",
+        secret: PHRASE,
+        address: PHRASE_ADDRESS,
+    },
+    {
+        tab: "tab-privkey",
+        field: "import-private-key",
+        secret: PRIVATE_KEY,
+        address: new Wallet(PRIVATE_KEY).address,
+    },
+    {
+        tab: "tab-xprv",
+        field: "import-xprv-key",
+        secret: XPRV,
+        address: PHRASE_ADDRESS,
+    },
+];
+
+afterEach(() => {
+    cleanupPopup();
+});
+
+describe("the first wallet's first address is active right away", () => {
+    test.each(TABS)(
+        "added from $tab, Receive opens on it",
+        async ({ tab, field, secret, address }) => {
+            const page = await bootPopup(undefined);
+            expect(page.pageErrors).toEqual([]);
+            await page.click("btn-welcome-add");
+            await page.click(tab);
+            page.node(field).value = secret;
+            page.node("add-wallet-password").value = PASSWORD;
+            page.node("add-wallet-password-confirm").value = PASSWORD;
+            await page.click("btn-add-wallet-confirm");
+            expect(page.visibleViews()).toEqual(["main"]);
+
+            await page.click("btn-main-receive");
+            expect(page.visibleViews()).toEqual(["receive"]);
+            expect(page.node("receive-address-block").dataset.full).toBe(
+                address,
+            );
+        },
+    );
+});

tests/support/popupBoot.js

@@ -258,12 +258,17 @@ async function bootPopup(stored, options) {
         formatAddressTotal: () => "",
         getAddressValue: () => ({ usd: null, partial: false }),
     }));
+    // scanForAddresses() answers in the real one's shape, a scan that found
+    // no used address: AddWallet reads `addresses` from it.
     jest.doMock("../../src/shared/balances", () => ({
         fetchTokenBalances: jest.fn(async () => []),
         refreshBalances: jest.fn(async () => {}),
         lookupTokenInfo: jest.fn(async () => null),
         getProvider: () => ({}),
-        scanForAddresses: jest.fn(async () => []),
+        scanForAddresses: jest.fn(async () => ({
+            addresses: [],
+            nextIndex: 1,
+        })),
     }));
     // filterTransactions() answers in the real one's shape: Home,
     // AddressDetail and AddressToken read both fields, and a bare list makes

tests/typedDataPermit.test.js

@@ -28,7 +28,7 @@ globalThis.chrome = {
     storage: { local: { get: async () => ({}), set: async () => {} } },
 };
 
-const { getAddress, MaxUint256, TypedDataEncoder } = require("ethers");
+const { getAddress, MaxUint256 } = require("ethers");
 const { state } = require("../src/shared/state");
 const { decryptWithPassword } = require("../src/shared/vault");
 const approval = require("../src/popup/views/approval");
@@ -662,107 +662,3 @@ describe("the sign screen refuses typed data for another chain", () => {
         expect(node("btn-approve-sign").disabled).toBe(false);
     });
 });
-
-// ethers signs a `bool` field by whether its value is truthy in JavaScript:
-// the string "false" is signed as true, and a field left out as false. The
-// screen would show one value while another is signed, so such typed data is
-// refused, and so is any declared field left out of the message
-// (https://git.eeqj.de/sneak/AutistMask/issues/552). DAI's older permit
-// declares the `bool` field `allowed`.
-describe("the sign screen refuses a message ethers would sign differently", () => {
-    const NOT_A_BOOL =
-        'The field "allowed" is not true or false, so this typed data cannot be signed.';
-    const MISSING =
-        'The field "allowed" is missing from the message, so this typed data cannot be signed.';
-
-    function daiPermit(allowed) {
-        return { ...DAI_PERMIT, message: { ...DAI_PERMIT.message, allowed } };
-    }
-
-    const withoutAllowed = {
-        ...DAI_PERMIT,
-        message: { ...DAI_PERMIT.message },
-    };
-    delete withoutAllowed.message.allowed;
-
-    beforeEach(() => {
-        decryptWithPassword.mockClear();
-    });
-
-    test('ethers signs "false" as true, and a bool left out as false', () => {
-        const hash = (data) =>
-            TypedDataEncoder.hash(
-                data.domain,
-                { Permit: data.types.Permit },
-                data.message,
-            );
-        expect(hash(daiPermit("false"))).toBe(hash(daiPermit(true)));
-        expect(hash(withoutAllowed)).toBe(hash(daiPermit(false)));
-    });
-
-    test('a bool sent as the string "false" shows the error, with Sign disabled', async () => {
-        await openSignScreen(daiPermit("false"));
-        expect(node("approve-sign-error").textContent).toBe(NOT_A_BOOL);
-        expect(node("btn-approve-sign").disabled).toBe(true);
-    });
-
-    test("a bool left out shows the error, with Sign disabled", async () => {
-        await openSignScreen(withoutAllowed);
-        expect(node("approve-sign-error").textContent).toBe(MISSING);
-        expect(node("btn-approve-sign").disabled).toBe(true);
-    });
-
-    test("Sign clicked anyway decrypts and signs nothing", async () => {
-        const sent = await openSignScreen(daiPermit("false"));
-        node("approve-sign-password").value = "any password";
-        await click("btn-approve-sign");
-
-        expect(decryptWithPassword).not.toHaveBeenCalled();
-        expect(sent.map((msg) => msg.type)).not.toContain(
-            "AUTISTMASK_SIGN_RESPONSE",
-        );
-        expect(node("approve-sign-error").textContent).toBe(NOT_A_BOOL);
-    });
-
-    test("a well-formed message leaves Sign enabled", async () => {
-        for (const allowed of [true, false]) {
-            await openSignScreen(daiPermit(allowed));
-            expect(node("approve-sign-error").textContent).toBe("");
-            expect(node("btn-approve-sign").disabled).toBe(false);
-        }
-    });
-
-    test("a field left out inside a list item is named by its place", () => {
-        const [first, second] = PERMIT_BATCH.message.details;
-        const withoutNonce = { ...second };
-        delete withoutNonce.nonce;
-        const data = {
-            ...PERMIT_BATCH,
-            message: {
-                ...PERMIT_BATCH.message,
-                details: [first, withoutNonce],
-            },
-        };
-        expect(typedDataRefusal(request(data))).toBe(
-            'The field "details[1].nonce" is missing from the message, so this typed data cannot be signed.',
-        );
-    });
-
-    // A plain lookup of a field named after a built-in object property reads
-    // back a function, which ethers would sign as true.
-    test("a field named after a built-in object property is missing when left out", () => {
-        const data = {
-            ...LOGIN,
-            types: {
-                ...LOGIN.types,
-                Login: [
-                    ...LOGIN.types.Login,
-                    { name: "constructor", type: "bool" },
-                ],
-            },
-        };
-        expect(typedDataRefusal(request(data))).toBe(
-            'The field "constructor" is missing from the message, so this typed data cannot be signed.',
-        );
-    });
-});

tests/wallet.test.js

@@ -416,7 +416,7 @@ describe("extended key depth", () => {
         expect(() =>
             wallet.getSignerForAddress(
                 { type: "xprv" },
-                { address: VECTOR_ADDRESSES[0], index: 0 },
+                0,
                 accountXprv(VECTOR_PHRASE),
             ),
         ).toThrow(/master/i);
@@ -504,7 +504,7 @@ describe("getSignerForAddress", () => {
     test.each([0, 1, 2])("hd wallet, address index %i", (index) => {
         const signer = wallet.getSignerForAddress(
             { type: "hd" },
-            { address: VECTOR_ADDRESSES[index], index },
+            index,
             VECTOR_PHRASE,
         );
 
@@ -515,7 +515,7 @@ describe("getSignerForAddress", () => {
     test.each([0, 1, 2])("xprv wallet, address index %i", (index) => {
         const signer = wallet.getSignerForAddress(
             { type: "xprv" },
-            { address: VECTOR_ADDRESSES[index], index },
+            index,
             masterXprv(VECTOR_PHRASE),
         );
 
@@ -527,7 +527,7 @@ describe("getSignerForAddress", () => {
         for (const index of [0, 1, 2]) {
             const signer = wallet.getSignerForAddress(
                 { type: "privkey" },
-                { address: VECTOR_ADDRESSES[1], index },
+                index,
                 VECTOR_PRIVATE_KEYS[1],
             );
 
@@ -535,54 +535,10 @@ describe("getSignerForAddress", () => {
         }
     });
 
-    // https://git.eeqj.de/sneak/AutistMask/issues/510: an address whose stored
-    // index does not derive it, or a private key that is not its key.
-    test.each([
-        ["hd", { address: VECTOR_ADDRESSES[2], index: 1 }, VECTOR_PHRASE],
-        [
-            "xprv",
-            { address: VECTOR_ADDRESSES[2], index: 1 },
-            masterXprv(VECTOR_PHRASE),
-        ],
-        ["privkey", { address: VECTOR_ADDRESSES[2] }, VECTOR_PRIVATE_KEYS[1]],
-    ])(
-        "%s wallet refuses a key that is not the address's own",
-        (type, addr, secret) => {
-            expect(() =>
-                wallet.getSignerForAddress({ type }, addr, secret),
-            ).toThrow(
-                "The key this wallet holds for " +
-                    VECTOR_ADDRESSES[2] +
-                    " belongs to a different address, so it was not used.",
-            );
-        },
-    );
-
-    // An HD or xprv address record without a usable `index` is refused in a
-    // sentence, not with what ethers says about the value it was handed.
-    test.each([
-        ["hd", VECTOR_PHRASE],
-        ["xprv", masterXprv(VECTOR_PHRASE)],
-    ])("%s wallet refuses an address with no valid index", (type, secret) => {
-        for (const index of [undefined, null, -1, 1.5, "1"]) {
-            expect(() =>
-                wallet.getSignerForAddress(
-                    { type },
-                    { address: VECTOR_ADDRESSES[1], index },
-                    secret,
-                ),
-            ).toThrow(
-                "No derivation index is stored for " +
-                    VECTOR_ADDRESSES[1] +
-                    ", so its key cannot be derived.",
-            );
-        }
-    });
-
     test("the returned signer signs recoverably as the expected address", async () => {
         const signer = wallet.getSignerForAddress(
             { type: "hd" },
-            { address: VECTOR_ADDRESSES[1], index: 1 },
+            1,
             VECTOR_PHRASE,
         );
         const message = "AutistMask derivation test";

tests/walletDefects.test.js

@@ -55,7 +55,7 @@ function healthyXprvWallet(name = "Master") {
         xpub,
         nextIndex: 1,
         encryptedSecret: "irrelevant-to-these-tests",
-        addresses: [{ address: firstAddress, index: 0, balance: "0.0000" }],
+        addresses: [{ address: firstAddress, balance: "0.0000" }],
     };
 }
 
@@ -74,11 +74,7 @@ function brokenXprvWallet(name = "Imported xprv") {
         nextIndex: 1,
         encryptedSecret: "irrelevant-to-these-tests",
         addresses: [
-            {
-                address: node.deriveChild(0).address,
-                index: 0,
-                balance: "0.0000",
-            },
+            { address: node.deriveChild(0).address, balance: "0.0000" },
         ],
     };
 }
@@ -574,7 +570,7 @@ describe("no path throws an unhandled error for a defective wallet", () => {
         try {
             wallet.getSignerForAddress(
                 { type: "xprv" },
-                brokenXprvWallet().addresses[0],
+                0,
                 accountXprv(VECTOR_PHRASE),
             );
         } catch (e) {
@@ -589,7 +585,7 @@ describe("no path throws an unhandled error for a defective wallet", () => {
     test("a healthy xprv wallet signs as it always did", () => {
         const signer = wallet.getSignerForAddress(
             { type: "xprv" },
-            healthyXprvWallet().addresses[0],
+            0,
             masterXprv(VECTOR_PHRASE),
         );