fix: a V4 step of chained swap actions shows what the user receives (closes #563)

A V4 step's input side is the currency SETTLE or SETTLE_ALL names, else
the one currency some swap action spends and none buys; its output side
is the currency TAKE or TAKE_ALL names, else the one some swap action
buys and none spends. Amount and Min. received come from those actions,
summed when several exact-in actions each state one. A step with an
unread swap action is named only by SETTLE, SETTLE_ALL, TAKE and
TAKE_ALL, and shows no figure. A side a step with a swap action leaves
unknown shows no other step's token or figure. Before, the first swap
action set both sides, SETTLE_ALL and TAKE_ALL went unread, and a
SWAP_EXACT_OUT was read as spending its path's last currency.

Model: opus-5-5

.gitea/workflows/e2e.yml

@@ -35,10 +35,10 @@ on: [push]
 jobs:
     e2e-chrome:
         runs-on: ubuntu-latest
-        # Bounds the image build, a cold cache included, and both Chrome
+        # Bounds the image build, a cold cache included, and the three Chrome
         # programs, so a hung browser frees the shared runner. README.md
         # "In CI" has the measured times.
-        timeout-minutes: 20
+        timeout-minutes: 40
         steps:
             # actions/checkout v4.2.2, 2026-02-22
             - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683

Makefile

@@ -1,4 +1,4 @@
-.PHONY: bootstrap setup install test test-e2e test-e2e-firefox lint fmt fmt-check check check-censored docker hooks build build-debug package vendor-blocklist icons clean dev
+.PHONY: bootstrap setup install test test-e2e test-e2e-firefox lint fmt fmt-check check check-censored docker hooks build build-debug package vendor-blocklist icons enrich-tokens apply-enrichment clean dev
 
 # Standard targets are thin shims; the implementations live in script/
 # per the scripts-to-rule-them-all pattern (see the Entrypoints section
@@ -111,6 +111,20 @@ vendor-blocklist:
 icons:
 	@node script/lib/icons.js
 
+# Fetch a name and a website for every token in src/shared/tokenList.js into
+# script/lib/token-enrichment.json. Run deliberately, land the diff: the names
+# come from live data, so a later run can return different ones.
+enrich-tokens:
+	@node script/lib/enrich-tokens.js
+
+# Write the names and websites in script/lib/token-enrichment.json into
+# src/shared/tokenList.js. Commit the result with the data file:
+# tests/applyEnrichment.test.js fails while the list differs from what this
+# writes, or while an address in the data or in the script's table of websites
+# matches no entry in the list.
+apply-enrichment:
+	@node script/lib/apply-enrichment.js
+
 clean:
 	@rm -rf dist/ release/
 

README.md

@@ -250,11 +250,13 @@ provide:
   nowhere in the working tree or under `dist/` outside its documented
   exceptions: the pinned source reference in `script/vendor-blocklist`, the two
   provider-shim identifiers in `src/content/inpage.js`, and one ERC-20's
-  on-chain name in `src/shared/tokenList.js`. Each is scoped to that path and
-  fails anywhere else. Run by the `lint` phase, so part of `make check`; it
-  inspects `dist/` when there is one and says loudly when there is not, and the
-  build context of that phase never has one. `make build` re-runs it with
-  `--require-dist`, so a build artifact is always covered
+  on-chain name in `src/shared/tokenList.js` and in
+  `script/lib/token-enrichment.json`, the fetched data that file's names are
+  written from. Each is scoped to the paths named and fails anywhere else. Run
+  by the `lint` phase, so part of `make check`; it inspects `dist/` when there
+  is one and says loudly when there is not, and the build context of that phase
+  never has one. `make build` re-runs it with `--require-dist`, so a build
+  artifact is always covered
 - `script/package` — produce the release artifacts: `make build` first, so the
   archives can only ever be made from a `dist/` that has been verified against
   that build's own receipt as a RELEASE build, then one self-contained,
@@ -326,6 +328,19 @@ The Makefile shims to those. It also carries a few targets that have no
   that already holds the drawn image, the same IHDR and every pixel, is left
   untouched. Commit the files with the drawing: `make check` fails while their
   image differs from what it draws
+- `make enrich-tokens` — fetch the name of each token in
+  `src/shared/tokenList.js` from CoinGecko's coin list and its website from the
+  `ethereum-lists/tokens` repository, at a pinned commit, into
+  `script/lib/token-enrichment.json`, by running `script/lib/enrich-tokens.js`.
+  CoinGecko's list is live and has no fixed version, so a later run can return
+  different names
+- `make apply-enrichment` — write the names and URLs in
+  `script/lib/token-enrichment.json` into `src/shared/tokenList.js`, by running
+  `script/lib/apply-enrichment.js`, taking a URL from the table of project
+  websites in that script only where the fetched data has none. Commit the list
+  with the data file: `make check` fails while the list differs from what this
+  writes. Neither target changes which tokens are on the list, and no build runs
+  either
 - `make clean` — remove `dist/` and `release/`
 - `make dev` — run the build `make build` runs, without the checks that follow
   it, then run it again after every change to a file under `src/`, `manifest/`
@@ -347,6 +362,14 @@ are outside `make check`. Neither opens the popup from the toolbar button: both
 load its page in an ordinary tab, so what the toolbar popup itself adds, its
 size and its closing when it loses focus, is covered by neither.
 
+Each run builds its image under a tag of its own, `autistmask-e2e-chrome:` or
+`autistmask-e2e-firefox:` followed by twelve random hex digits, so two clones
+can run the same suite at once without one build taking the other's image away.
+The run removes that image, and its container if one is still running, after the
+suite passes or fails, on Ctrl-C, on `kill`, and when the terminal or SSH
+session it runs in closes. A run killed outright (`kill -9`) cannot clean up:
+its image stays under its tag until removed by hand with `docker image rm`.
+
 ### Chrome (`make test-e2e`)
 
 `make test-e2e` builds `dist/chrome/` and drives the **real popup in a real
@@ -464,6 +487,9 @@ papered over:
   forced by clicking Reveal and the settings gear in one page task, which a
   person cannot do; the case a person can hit, the first decrypt after the popup
   opens while libsodium is still loading, is not driven.
+- Approval windows open at 1280x720 whatever size the extension asks for, so
+  whether an approval screen fits its window is checked in the Firefox suite
+  only.
 
 Any test that drives a failure path on purpose declares the `console.error` it
 is about to provoke, via `errors.expect()`. That is not a mute: the declaration
@@ -527,6 +553,31 @@ one profile yields a single extension id, not two: Chrome does not load a second
 copy of an id it already has. The assertions are annotated as observations, so a
 Chrome that ever changes this fails the run instead of passing it.
 
+Last, `make test-e2e` runs `tests/e2e/slowApproval.js`, which leaves a
+transaction approval and a signature approval open for seven minutes with both
+windows minimized, then restores and approves both and requires the site to
+receive the hash of the transaction the stub node received and a signature that
+recovers to the address. Before the background worker kept itself running while
+an approval is pending, Chrome stopped it about six minutes in and neither
+request was ever answered
+([#540](https://git.eeqj.de/sneak/AutistMask/issues/540)). The windows are
+minimized through the DevTools protocol (`Browser.setWindowBounds`), and the run
+fails unless both pages then report themselves hidden: Chrome slows a hidden
+page's timers to once a minute, so anything the window did to keep the worker
+running would fail here. It is its own program and does not use Playwright:
+Playwright keeps DevTools attached to the background worker, and Chrome never
+stops a worker DevTools is attached to, so no wait in the suite above can show
+the worker stopping. It starts Chromium itself, speaks the DevTools protocol
+over `--remote-debugging-pipe`, and attaches to pages only. Before raising the
+approvals it requires the worker to stop on its own with nothing pending, so a
+run in which something else keeps the worker running fails. The site is
+connected, without "Remember my choice for this site", and the RPC endpoint set
+through the extension's own screens, against the loopback dApp page and stub
+node the Firefox suite also uses (`tests/e2e/dapp.js`). Once the worker has
+stopped, the run requires the site still to be told the address
+([#526](https://git.eeqj.de/sneak/AutistMask/issues/526)). Unlike the suite
+above, it does not fail on page errors.
+
 ### Firefox (`make test-e2e-firefox`)
 
 `make test-e2e-firefox` builds `dist/firefox/` and drives the **real popup in a
@@ -536,13 +587,16 @@ suite), wallet creation through the UI, the Add Token screen, and the dApp round
 trips — `eth_requestAccounts`, `personal_sign`, `wallet_switchEthereumChain`
 rejected and then approved, `eth_sendTransaction`, and a closed approval window
 rejecting with EIP-1193 4001 — driven through the real content script,
-background page and approval windows.
+background page and approval windows. The `personal_sign` prompt is also
+required to fit its window without scrolling sideways, with the extension's
+pages at 170% zoom.
 
 The suite lives in `tests/e2e/firefox/`. Its WebDriver client (`driver.js`) has
 **no npm dependencies at all**: it is built on global `fetch` and
-`child_process` against geckodriver's HTTP API. The dApp fixture (`dapp.js`) and
-the assertions do use `ethers`, and have to — a signature is recovered in the
-runner rather than believed from the extension, and the stub node has to answer
+`child_process` against geckodriver's HTTP API. The dApp fixture
+(`tests/e2e/dapp.js`, shared with `tests/e2e/slowApproval.js`) and the
+assertions do use `ethers`, and have to — a signature is recovered in the runner
+rather than believed from the extension, and the stub node has to answer
 `eth_sendRawTransaction` with the hash `ethers` computes for the artifact it
 sent, or `provider.broadcastTransaction()` refuses the answer.
 
@@ -648,16 +702,16 @@ Three limits are worth knowing, all real differences from the Chrome suite:
 - **Almost nothing is stubbed, which inverts the coverage of network-dependent
   code.** The container still runs with `--network none`, so the run is offline
   and no request can escape. The one thing it can reach is the loopback fixture
-  in `tests/e2e/firefox/dapp.js`, which serves the dApp page and a JSON-RPC node
-  and which the extension's `rpcUrl` is pointed at for the dApp steps; a
-  JSON-RPC method that fixture does not model fails the run rather than
-  answering `null`. Everything else, Blockscout and the price feed among it, has
-  no fixture and simply fails, and the extension swallows its own fetch
-  failures, so only the _failure_ branches of that code are ever executed. A
-  `ReferenceError` in the success path of `renderTransactions`, or of price
-  rendering, passes this suite green. The offline run is also weaker than the
-  Chrome suite's interception for those calls: it proves nothing got out, but it
-  cannot report which requests were attempted.
+  in `tests/e2e/dapp.js`, which serves the dApp page and a JSON-RPC node and
+  which the extension's `rpcUrl` is pointed at for the dApp steps; a JSON-RPC
+  method that fixture does not model fails the run rather than answering `null`.
+  Everything else, Blockscout and the price feed among it, has no fixture and
+  simply fails, and the extension swallows its own fetch failures, so only the
+  _failure_ branches of that code are ever executed. A `ReferenceError` in the
+  success path of `renderTransactions`, or of price rendering, passes this suite
+  green. The offline run is also weaker than the Chrome suite's interception for
+  those calls: it proves nothing got out, but it cannot report which requests
+  were attempted.
 - **The site-connection prompt always opens in a window of its own.** The
   profile turns off `extensions.openPopupWithoutUserGesture.enabled`, so
   `src/background/index.js` falls back from the toolbar popup, which WebDriver
@@ -707,11 +761,13 @@ installing Firefox, geckodriver and their system libraries. Both scripts now
 build their image with `--no-cache`, so every run pays the cold figure. Those
 `e2e-chrome` runs predate the cases that wait in real time for a receipt to end
 in error. `make test-e2e` took 3m51s locally with its image cached, so with the
-image rebuilt every run, an `e2e-chrome` run comes to about seven minutes.
+image rebuilt every run, an `e2e-chrome` run comes to about seven minutes. The
+approvals left open for seven minutes (`tests/e2e/slowApproval.js`) add about
+eight more, so about fifteen.
 
 Each e2e job has a `timeout-minutes` cap, so a hung build or browser ends the
 job instead of holding the shared runner: `e2e-firefox` 15 minutes and
-`e2e-chrome` 20, each over two and a half times the job's slowest cold run. A
+`e2e-chrome` 40, each over two and a half times the job's slowest cold run. A
 job that reaches its cap has hung; read it as a hang, not as a slow run to
 retry. The `check` job has no cap: `.gitea/workflows/check.yml` is the canonical
 copy from `sneak/prompts`, kept byte-identical.
@@ -804,10 +860,28 @@ on the next event. Two consequences shape every recurring job in the background:
 - Module-level variables do not survive either. Anything that must be remembered
   across a restart goes in extension storage. `localStorage` does not exist in a
   service worker at all — the one remaining user of it, `src/shared/ens.js`,
-  runs only in the popup and is marked as such.
+  runs only in the popup and is marked as such. The sites allowed without
+  "Remember my choice for this site" are kept in the browser's session storage
+  (`storage.session`), which outlives the worker but not the browser, so such a
+  connection lasts until it is ended or the browser closes. Firefox has session
+  storage from version 115, the minimum `manifest/firefox.json` declares.
 
-The job also carries a freshness guard, and a guard must never be timed to the
-alarm period it gates. The guard is measured from the moment the last run
+Pending approvals are the exception: an approval waiting for the user, and the
+site's request waiting on it, live only in the worker's memory, and only the
+worker that received the request can answer it. Left alone, Chrome stopped the
+worker about six minutes after a site's request even with the approval window
+still open, and the user's answer then reached nobody. So the worker keeps
+itself running while any approval is pending: every approval is added through
+`addPendingApproval()`, which starts a `setInterval` that calls
+`runtime.getPlatformInfo()` every 20 seconds, and Chrome counts each extension
+call as activity. The timer stops itself once nothing is pending, and the worker
+then stops as it otherwise would. The timer is the worker's own, so it does not
+depend on the approval window being visible; a timer in the window would,
+because Chrome slows a hidden page's timers to once a minute. A worker that
+stops for another reason, a crash say, still loses the approvals open in it.
+
+The balance refresh carries a freshness guard, and a guard must never be timed
+to the alarm period it gates. The guard is measured from the moment the last run
 finished, which is one run-duration after the alarm that started it, so a guard
 of exactly one period vetoes the very next tick and the real cadence becomes two
 periods. The balance refresh guard exists to skip work an open popup has already
@@ -893,8 +967,16 @@ discoverable.
   enough that vanilla JS with simple view switching is sufficient. A framework
   would add bundle size, build complexity, and attack surface for no benefit at
   this scale.
-- **360x600 popup**: Standard browser extension popup dimensions. The UI is
-  designed for this fixed viewport.
+- **396x600 popup**: The page is 396 pixels wide (`body` in
+  `src/popup/styles/main.css`), and 600 pixels is as tall as the browser lets
+  the toolbar popup grow. The UI is designed for this fixed viewport. The window
+  an approval opens in is given the same size. The browser counts the window's
+  frame in that width, and a screen taller than the window gives some of it to a
+  vertical scrollbar, so once the approval's screen is up the page widens its
+  window by however far it would scroll sideways, scaled by the browser's zoom.
+  Firefox draws some zoom steps a little larger than the zoom it reports, so the
+  page measures again once the window has grown, and widens it again while it
+  still falls short.
 
 #### No Layout Shift
 
@@ -1089,8 +1171,8 @@ read:
   amount of one step that names an input token or amount: the last
   `PERMIT2_PERMIT` step if there is one, otherwise the first V2 or V3 exact-in,
   V2 exact-out, `WRAP_ETH` or V4 swap step. A V2 exact-out step gives its
-  `amountInMax`, and a V4 swap step the `amountIn` of its first readable
-  exact-in action.
+  `amountInMax`, and a V4 swap step the `amountIn` of the swap action that
+  spends its input currency, as described below.
 - `Whatever an earlier step sent to the pair (V2 already paid)`: the swap's
   `Amount` line, when the amount it shows is a V2 exact-in `amountIn` of zero.
   The router reads that zero as "the pair already holds the input tokens": the
@@ -1110,8 +1192,33 @@ read:
 
 The swap's `Token In` and `Token Out` lines name a currency, not an amount; each
 reads `Unknown (not named in the calldata)` when the decoder found no token for
-that side. An `UNWRAP_WETH` step makes `Token Out` ETH only when the output side
-is WETH, on mainnet or Sepolia, or when no step set the output side; a WETH
+that side, or `Unknown (could not be decoded)` instead when a V4 swap action in
+the transaction could not be read (see Transaction Decoding below). A V4 step
+with a swap action sets both sides as a swap step does, following three rules:
+
+1. Its input side is the currency its `SETTLE` or `SETTLE_ALL` names, or else
+   the one currency that some swap action in the step spends and none buys. Its
+   output side is the currency its `TAKE` or `TAKE_ALL` names, or else the one
+   currency that some swap action buys and none spends. If there is not exactly
+   one such currency, that side is unknown, and no other step's token or figure
+   is shown for it. A step that buys WETH with USDT and USDC with that WETH,
+   with nothing naming its sides, reads `Swap USDT → USDC`.
+2. `Amount` is the `amountIn` of the swap action that spends the input currency.
+   If several exact-in actions spend it, each with a stated amount, it is their
+   sum; in any other case there is no `Amount` line. The decoder reads no amount
+   from an exact-out action, and an open delta is not a stated amount.
+   `Min. received` is found the same way, from the `amountOutMin` of the actions
+   that buy the output currency.
+3. If any swap action in the step could not be read, only `SETTLE`,
+   `SETTLE_ALL`, `TAKE` and `TAKE_ALL` name its sides, and there is no `Amount`
+   or `Min. received` line. A side they did not name is unknown, and no other
+   step's token or figure is shown for it.
+
+A V4 step with no swap action sets only the sides its `SETTLE`, `SETTLE_ALL`,
+`TAKE` or `TAKE_ALL` names.
+
+An `UNWRAP_WETH` step makes `Token Out` ETH only when the output side is WETH,
+on mainnet or Sepolia, or when no step set the output side; a WETH
 `Min. received` figure then reads in ETH. Otherwise `Token Out` and
 `Min. received` keep the output side's own token and figure, whether the swap
 was paid in ETH or in a token: a V2 exact-out swap that buys USDC and then
@@ -1192,7 +1299,16 @@ 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.
+- 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.
 - The user can have multiple wallets, each with multiple addresses (HD) or a
   single address (key).
 
@@ -1464,8 +1580,14 @@ 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. When the scan finds two or more used addresses, they replace the
+      wallet's list, which then holds the first address only if it was used. If
+      the first address was active and is not in the new list, the new list's
+      first address becomes the active one and `AUTISTMASK_ACTIVE_CHANGED` is
+      broadcast.
     - "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
@@ -1518,6 +1640,9 @@ 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
@@ -1589,7 +1714,13 @@ view would leave a wallet one click from deletion.
 - **Transitions**:
     - "Review" (valid inputs, ENS resolved) → **ConfirmTx**
     - "Review" with an unresolvable ENS name or an invalid amount → flash
-      message, no screen change
+      message, no screen change. An amount is valid when it is a number above
+      zero, written as digits with at most one decimal point, with nothing but
+      zeros after the token's last decimal place. ETH has 18 places, and a token
+      with more, or with an unknown number, is held to 18. Zeros past those
+      places leave the amount unchanged, so `1.0000000` of a 6-place token
+      passes and is sent as exactly 1. ConfirmTx makes the same check before
+      anything can be sent
     - "Back" → previous screen (Home, AddressDetail, or AddressToken)
 
 #### ConfirmTx (`confirm-tx`)
@@ -1645,8 +1776,21 @@ view would leave a wallet one click from deletion.
       the contract's own answer is read at signing time only to be compared with
       it, and a disagreement is a refusal rather than a preference for either
       value (`src/shared/transferAmount.js`)
+    - "Sign & Send" after the active network was switched in Settings while this
+      screen was open → nothing is signed; "The active network changed after
+      this transaction was reviewed, so it was not sent. Please go back and
+      review it again." in the errors box, no screen change. The transaction
+      carries the chain id of the network the screen was shown for, so it cannot
+      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`)
@@ -1654,7 +1798,11 @@ view would leave a wallet one click from deletion.
 - **When**: Transaction has been broadcast, waiting for on-chain confirmation.
 - **Elements**:
     - "Transaction Broadcast" heading (no back button — tx is irreversible)
-    - Amount + symbol
+    - Amount + symbol. For a swap the approval screen showed no `Amount` for,
+      such as one whose V4 swap action could not be read or a V4 exact-out swap,
+      `Unknown (could not be decoded)` with no symbol, not the transaction's ETH
+      value. When that swap's `Token In` is `ETH (native)`, the transaction's
+      ETH value in the network's currency, as for any other transaction
     - To: color dot + full address + etherscan link; for a contract creation,
       which has no recipient, "This transaction creates a new contract. It has
       no recipient." instead
@@ -1701,7 +1849,9 @@ view would leave a wallet one click from deletion.
 - **When**: Transaction broadcast failed, or timed out waiting for confirmation.
 - **Elements**:
     - "Transaction Failed" heading
-    - Amount + symbol
+    - Amount + symbol, or for a swap the approval screen showed no `Amount` for,
+      the same as on WaitTx: `Unknown (could not be decoded)`, unless its
+      `Token In` is `ETH (native)`
     - To: color dot + full address + etherscan link, or for a contract creation
       the same sentence as on WaitTx
     - Error message (dashed border box)
@@ -1814,7 +1964,7 @@ view would leave a wallet one click from deletion.
       under any address, with remove buttons
     - Connected Sites: the origins of the sites allowed without "Remember my
       choice" that are still connected, with remove buttons. Only the background
-      holds these, in memory, and Settings asks it for them with
+      holds these, in session storage, and Settings asks it for them with
       `AUTISTMASK_GET_CONNECTED_SITES`
     - Denied Sites: the origins remembered as denied, under any address, with
       remove buttons
@@ -1833,9 +1983,10 @@ view would leave a wallet one click from deletion.
       its origin is dropped from Allowed Sites under every address, and
       `AUTISTMASK_REMOVE_SITE` has the background end every connection approved
       without "Remember" from that origin, under any address, and send
-      `accountsChanged` with an empty list to the open tabs of that origin. The
-      same host under another scheme or port is another site and is left alone.
-      Only the extension's own pages may send either message
+      `accountsChanged` with an empty list to the open tabs of that origin.
+      Settings waits for the background's answer before it draws the lists
+      again. The same host under another scheme or port is another site and is
+      left alone. Only the extension's own pages may send either message
     - `[x]` on a denied site → forgets the refusal, in place; it connects
       nothing and tells the background nothing
     - Ten clicks on the version → reveals the Debug well (no screen change)
@@ -1896,8 +2047,8 @@ view would leave a wallet one click from deletion.
       (`src/shared/walletDelete.js`)
     - Either way, every address the wallet held loses its site permissions of
       both kinds: the remembered ones in storage, and the connections approved
-      without "Remember", which only the background holds, in memory, and drops
-      on `AUTISTMASK_ADDRESSES_REMOVED`
+      without "Remember", which only the background holds, in session storage,
+      and drops on `AUTISTMASK_ADDRESSES_REMOVED`
     - "Confirm Delete" (wrong password) → "That password is incorrect. Please
       try again." on the error line, nothing deleted
     - "I have lost my password" → **DeleteWalletLostPassword**
@@ -2010,8 +2161,8 @@ view would leave a wallet one click from deletion.
   one in this wallet follows the splice.
 - The address loses its site permissions of both kinds, whether or not it was
   the active one: the remembered ones in storage, and any connection approved
-  without "Remember", which only the background holds, in memory, and drops on
-  `AUTISTMASK_ADDRESSES_REMOVED`.
+  without "Remember", which only the background holds, in session storage, and
+  drops on `AUTISTMASK_ADDRESSES_REMOVED`.
 - The wallet's derivation counter (`nextIndex`) is not rewound, so "+" derives a
   fresh address rather than handing back the one just removed.
 
@@ -2040,14 +2191,22 @@ view would leave a wallet one click from deletion.
   `wallet_requestPermissions` and is on neither the allowed nor the denied list.
   A site is its full origin, `scheme://host[:port]`, on both lists and for a
   connection allowed without "Remember": a choice for `https://dapp.example`
-  says nothing about `http://dapp.example` or another port of that host. The
-  background script prefers the toolbar popup (`action.openPopup()`) and falls
-  back to a separate popup window (`src/background/index.js`,
-  `requestApproval()`). Only one exists per site at a time: a further connection
-  request from a site whose prompt is still unanswered is refused with EIP-1193
-  code `-32002` and opens no new prompt. If that prompt was in a toolbar popup
-  that closed before it connected, and the toolbar popup has since been set to
-  open something else, the refused request shows that prompt again.
+  says nothing about `http://dapp.example` or another port of that host. A
+  request whose origin has no host names no site, so it is refused with EIP-1193
+  code `4100` and opens no prompt. Two such origins are `null`, which the
+  browser reports for a page with an opaque origin, such as one its server
+  sandboxes with a Content-Security-Policy, and `file://`, which Chrome reports
+  for a local file. Nor is such a page told the active address by
+  `accountsChanged`, even at a connected site's URL: the background names the
+  origin of the tab's URL on the event, and the content script passes the
+  address on only to a page whose own origin is that one. The background script
+  prefers the toolbar popup (`action.openPopup()`) and falls back to a separate
+  popup window (`src/background/index.js`, `requestApproval()`). Only one exists
+  per site at a time: a further connection request from a site whose prompt is
+  still unanswered is refused with EIP-1193 code `-32002` and opens no new
+  prompt. If that prompt was in a toolbar popup that closed before it connected,
+  and the toolbar popup has since been set to open something else, the refused
+  request shows that prompt again.
 - **Elements**:
     - "Connection Request" heading
     - Phishing warning banner (shown when the hostname is on the phishing
@@ -2075,8 +2234,14 @@ view would leave a wallet one click from deletion.
   artifact can be compared with it field for field. A nonce the site supplies is
   ignored: the nonce is always the account's next nonce from the node, so a site
   cannot replace one of the user's pending transactions or leave this one stuck
-  behind a gap. A request that cannot be populated — unreachable node, reverting
-  gas estimate — opens no window and is failed back to the site. Only one
+  behind a gap. A gas limit the site supplies, as `gas` or `gasLimit`, is the
+  one shown and signed in place of the node's estimate, but the node still
+  estimates the transaction with that limit, as the check that it neither
+  reverts nor runs out of gas; a request that gives both with different values
+  is refused with EIP-1474 code `-32602`. A request that cannot be populated —
+  unreachable node, reverting gas estimate — opens no window and is failed back
+  to the site, with the node's own error code and data when the node refused it,
+  so the site can decode a revert, and with `-32603` otherwise. Only one
   transaction approval exists at a time: populating fixes the nonce, so a second
   `eth_sendTransaction` arriving while one is unanswered is refused with
   EIP-1193 code `-32002` rather than being populated at the same nonce. It opens
@@ -2110,6 +2275,9 @@ 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
@@ -2128,7 +2296,12 @@ view would leave a wallet one click from deletion.
       blocklist)
     - Site origin (bold, scheme and port included) + "wants you to sign a
       message"
-    - Danger warning box (shown for `eth_sign`, which signs a raw hash)
+    - Warning box, shown for `eth_sign`: "This site used the older eth_sign
+      method. The data will be signed as a personal message." An `eth_sign`
+      request names the address first and the data second. Its data is signed
+      exactly as a `personal_sign` message is, as an EIP-191 personal message,
+      which is what the Ethereum JSON-RPC specification defines `eth_sign` to
+      return.
     - Type: "Personal message" or "Typed data (EIP-712)"
     - From: color dot + full address + etherscan link
     - Message: for `personal_sign` and `eth_sign`, the text the message's bytes
@@ -2143,7 +2316,12 @@ view would leave a wallet one click from deletion.
       Bytes that are not UTF-8 are shown as "This message is not text." For
       typed data, formatted domain/type/message fields (EIP-712). The primary
       type shown is the one ethers signs, derived from the typed data's `types`,
-      not the type the site states.
+      not the type the site states. The message shows only the fields that type
+      declares, at every level of nesting and in the type's order: ethers signs
+      those and drops any other key. Typed data carrying other keys is not
+      refused; each such key is listed after the message under "Not part of the
+      signature", by its place in the message (`details.note`,
+      `details[1].note`) and its value.
     - Token permission warning, at the top of the message (typed data whose
       primary type is `Permit`, as in EIP-2612, or one of Permit2's signature
       types): "⚠️ TOKEN PERMISSION: Signing this lets the spender below take the
@@ -2164,6 +2342,13 @@ 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
@@ -2690,7 +2875,11 @@ Currently supported:
   or recipient, and amount.
 - **Uniswap Universal Router**: `execute()` calls — shows swap direction (e.g.
   "Swap USDT → ETH"), token addresses, amounts, execution steps, and deadline.
-  Decodes Permit2, V2/V3/V4 swaps, wrap/unwrap, and balance checks.
+  Decodes Permit2, V2/V3/V4 swaps, wrap/unwrap, and balance checks. A V4 swap
+  action is read only in the parameter shape deployed on mainnet and Sepolia,
+  not in the newer one on `v4-periphery` `main`, which adds a `minHopPriceX36`
+  field. An action in any other shape is not read, and its step is listed as
+  `V4 Swap (could not be decoded)`.
 
 ### Non-Goals Forever
 
@@ -2774,7 +2963,7 @@ exact URL, the commit it is pinned to and the sha256 of the bytes that commit
 serves, because a source reference nobody can verify is not a source reference.
 `script/check-censored` reads the name back out of that one file and fails the
 build wherever else it appears, save for three shipped-code literals it cannot
-avoid — each permitted only at the one path that carries it, and listed in that
+avoid — each permitted only at the paths that carry it, and listed in that
 script's header.
 
 ## Author

manifest/firefox.json

@@ -27,7 +27,8 @@
     "web_accessible_resources": ["src/content/inpage.js"],
     "browser_specific_settings": {
         "gecko": {
-            "id": "autistmask@sneak.berlin"
+            "id": "autistmask@sneak.berlin",
+            "strict_min_version": "115.0"
         }
     }
 }

script/check-censored

@@ -18,6 +18,8 @@
 #     (src/shared/balances.js), and this contract's on-chain name is that
 #     string, so censoring the repo cannot stop the wallet displaying it.
 #     Dropping the entry instead would cost the user MUSD spoof detection.
+#     script/lib/token-enrichment.json, the fetched data tokenList.js's names
+#     are written from, carries the same name for the same reason.
 #
 # Everything else fails, in the working tree and under dist/. The last two are
 # literals rather than whole files, so they are enforced by counting, and each
@@ -102,8 +104,8 @@ allowed_literals_for() {
     src/content/inpage.js | dist/*/src/content/inpage.js)
         printf 'is%s\n_%s\n' "$NAME" "$NAME" >"$ALLOWED_LITERALS_FILE"
         ;;
-    src/shared/tokenList.js | dist/*/src/background/index.js | \
-        dist/*/src/popup/index.js)
+    src/shared/tokenList.js | script/lib/token-enrichment.json | \
+        dist/*/src/background/index.js | dist/*/src/popup/index.js)
         printf '%s USD\n' "$NAME" >"$ALLOWED_LITERALS_FILE"
         ;;
     esac

script/lib/apply-enrichment.js

@@ -0,0 +1,159 @@
+// Writes the names and URLs in script/lib/token-enrichment.json, which
+// script/lib/enrich-tokens.js fetches, into the matching entries of
+// src/shared/tokenList.js: the name and url an entry already has are replaced,
+// and an entry without them gets them after its decimals. Where the fetched
+// data has no URL for a token, EXTRA_URLS below supplies one. An entry the data
+// does not mention is left as it is. An address in the data or in EXTRA_URLS
+// that matches no entry in tokenList.js, capitals included, is an error naming
+// that address. Run by
+// `make apply-enrichment`; no build runs it. tests/applyEnrichment.test.js
+// checks that the committed tokenList.js is exactly what this writes from the
+// committed data.
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const TOKEN_LIST = path.join(__dirname, "..", "..", "src/shared/tokenList.js");
+
+// Project websites by token address, each spelled as tokenList.js spells it. A
+// token gets its URL here only where the fetched data has none, so an address
+// the data has a URL for is never used.
+const EXTRA_URLS = {
+    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": "https://weth.io",
+    "0xdAC17F958D2ee523a2206206994597C13D831ec7": "https://tether.to",
+    "0xB8c77482e45F1F44dE1745F52C74426C631bDD52": "https://www.bnbchain.org",
+    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "https://www.circle.com/usdc",
+    "0xdC035D45d973E3EC169d2276DDab16f1e407384F": "https://sky.money",
+    "0x2AF5D2aD76741191D15Dfe7bF6aC92d4Bd912Ca3": "https://www.bitfinex.com",
+    "0x514910771AF9Ca656af840dff83E8264EcF986CA": "https://chain.link",
+    "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3": "https://ethena.fi",
+    "0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d":
+        "https://www.worldlibertyfinancial.com",
+    "0x6B175474E89094C44Da98b954EedeAC495271d0F": "https://makerdao.com",
+    "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8":
+        "https://www.paypal.com/us/digital-wallet/manage-money/crypto/pyusd",
+    "0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE": "https://shibatoken.com",
+    "0xdA5e1988097297dCdc1f90D4dFE7909e847CBeF6":
+        "https://www.worldlibertyfinancial.com",
+    "0xA0b73E1Ff0B80914AB6fe0444E65848C4C34450b": "https://crypto.com",
+    "0x582d872A1B094FC48F5DE31D3B73F2D9bE47def1": "https://ton.org",
+    "0x68749665FF8D2d112Fa859AA293F07A622782F38": "https://gold.tether.to",
+    "0x196C20DA81Fbc324EcdF55501e95Ce9f0bD84d14": "https://polkadot.network",
+    "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984": "https://uniswap.org",
+    "0x45804880De22913dAFE09f4980848ECE6EcbAf78":
+        "https://www.paxos.com/paxgold",
+    "0x3c3a81e81dc49A522A592e7622A7E711c06bf354": "https://www.mantle.xyz",
+    "0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9": "https://aave.com",
+    "0x75231F58b43240C9718Dd58B4967c5114342a86c": "https://www.okx.com",
+    "0x6982508145454Ce325dDbE47a25d4ec3d2311933": "https://www.pepe.vip",
+    "0x5A98FcBEA516Cf06857215779Fd812CA3beF1B32": "https://lido.fi",
+    "0xC18360217D8F7Ab5e7c516566761Ea12Ce7F9D72": "https://ens.domains",
+    "0xD533a949740bb3306d119CC777fa900bA034cd52": "https://curve.fi",
+    "0x111111111117dC0aa78b770fA6A738034120C302": "https://1inch.io",
+    "0x163f8C2467924be0ae7B5347228CABF260318753": "https://worldcoin.org",
+    "0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F": "https://synthetix.io",
+    "0xBBbbCA6A901c926F240b89EacB641d8Aec7AEafD": "https://loopring.org",
+    "0xC669928185DbCE49d2230CC9B0979BE6DC797957": "https://bitstable.finance",
+    "0xfAbA6f8e4a5E8Ab82F62fe7C39859FA577269BE3": "https://ondo.finance",
+    "0x6De037ef9aD2725EB40118Bb1702EBb27e4Aeb24": "https://www.render.com",
+    "0x4a220E6096B25EADb88358cb44068A3248254675": "https://www.quant.network",
+    "0xba5BDe662c17e2aDFF1075610382B9B691296350": "https://superrare.com",
+    "0xc00e94Cb662C3520282E6f5717214004A7f26888": "https://compound.finance",
+    "0xE41d2489571d322189246DaFA5ebDe1F4699F498": "https://0x.org",
+    "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e": "https://yearn.fi",
+    "0x6fB3e0A217407EFFf7Ca062D46c26E5d60a14d69": "https://iotex.io",
+    "0xF57e7e7C23978C3cAEC3C3548E3D615c346e79fF": "https://immutable.com",
+    "0x0F5D2fB29fb7d3CFeE444a200298f468908cC942": "https://decentraland.org",
+    "0x3845badAde8e6dFF049820680d1F14bD3903a5d0": "https://www.sandbox.game",
+    "0x6810e776880C02933D47DB1b9fc05908e5386b96": "https://gnosis.io",
+    "0x5f98805A4E8be255a32880FDeC7F6728C6568bA0": "https://www.liquity.org",
+    "0x0D8775F648430679A709E98d2b0Cb6250d2887EF":
+        "https://basicattentiontoken.org",
+    "0xc944E90C64B2c07662A292be6244BDf05Cda44a7": "https://thegraph.com",
+    "0x853d955aCEf822Db058eb8505911ED77F175b99e": "https://frax.finance",
+    "0x0000000000085d4780B73119b644AE5ecd22b376": "https://www.trueusd.com",
+    "0x3432B6A60D23Ca0dFCa7761B7ab56459D9C964D0": "https://frax.finance",
+    "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E": "https://curve.fi",
+    "0x808507121B80c02388fAd14726482e061B8da827": "https://pendle.finance",
+    "0xCa14007Eff0dB1f8135f4C25B34De49AB0d42766": "https://starknet.io",
+    "0x8457CA5040ad67fdebbCC8EdCE889A335Bc0fbFB": "https://alt.layer",
+    "0xB50721BCf8d664c30412Cfbc6cf7a15145234ad1": "https://arbitrum.io",
+    "0x6985884C4392D348587B19cb9eAAf157F13271cd": "https://layerzero.network",
+    "0xFe0c30065B384F05761f15d0CC899D4F9F9Cc0eB": "https://ethfi.org",
+    "0x5283D291DBCF85356A21bA090E6db59121208b44": "https://blur.io",
+    "0x43Dfc4159D86F3A37A5A4B3D4580b888ad7d4DDd": "https://dydx.exchange",
+    "0xcf0C122c6b73ff809C693DB761e7BaeBe62b6a2E": "https://floki.com",
+    "0xe53EC727dbDEB9E2d5456c3be40cFF031AB40A55": "https://superfarm.com",
+    "0x32353A6C91143bfd6C7d363B546e62a9A2489A20": "https://www.agora.finance",
+    "0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c": "https://www.euro-coin.com",
+    "0xA35923162C49cF95e6BF26623385eb431ad920D3": "https://www.turbo-eth.com",
+    "0x1151CB3d861920e07a38e03eEAd12C32178567F6": "https://bonk.com",
+    "0x090185f2135308BaD17527004364eBcC2D37e5F6": "https://spell.club",
+    "0xAf5191B0De278C7286d6C7CC6ab6BB8A73bA2Cd6": "https://stargate.finance",
+};
+
+// Returns tokenList, the text of tokenList.js, with the name and url of each
+// token in enrichment, the parsed data file, written into its entry.
+function applyEnrichment(tokenList, enrichment) {
+    for (const addr of Object.keys(EXTRA_URLS)) {
+        if (!tokenList.includes(`address: "${addr}"`)) {
+            throw new Error(
+                `No entry in src/shared/tokenList.js has the address ${addr} from EXTRA_URLS.`,
+            );
+        }
+    }
+
+    let result = tokenList;
+
+    for (const [addr, data] of Object.entries(enrichment)) {
+        // Escape special regex characters in the address
+        const escaped = addr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+        // Match the token block: { address: "...", symbol: "...", decimals: N, }
+        // and the name: "...", url: "..." after decimals when it has them.
+        // The closing }, may have trailing whitespace
+        const blockRe = new RegExp(
+            `(\\{\\s*address:\\s*"${escaped}",\\s*symbol:\\s*"[^"]+",\\s*decimals:\\s*\\d+)` +
+                `(?:,\\s*name:\\s*"(?:[^"\\\\]|\\\\.)*",\\s*url:\\s*"(?:[^"\\\\]|\\\\.)*")?` +
+                `,?(\\s*\\})`,
+        );
+
+        const match = result.match(blockRe);
+        if (!match) {
+            throw new Error(
+                `No entry in src/shared/tokenList.js matches the address ${addr} from script/lib/token-enrichment.json.`,
+            );
+        }
+
+        // A URL from EXTRA_URLS only where the fetched data has none.
+        const url = data.url || EXTRA_URLS[addr] || "";
+
+        // Build replacement: original fields + name + url
+        const nameEscaped = data.name
+            .replace(/\\/g, "\\\\")
+            .replace(/"/g, '\\"');
+        const urlEscaped = url.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        const replacement =
+            match[1] +
+            `,\n        name: "${nameEscaped}",` +
+            `\n        url: "${urlEscaped}",` +
+            match[2];
+
+        // A function, so a "$" in a name is not read as a replacement pattern.
+        result = result.replace(blockRe, () => replacement);
+    }
+
+    return result;
+}
+
+if (require.main === module) {
+    const enrichment = JSON.parse(
+        fs.readFileSync(path.join(__dirname, "token-enrichment.json"), "utf8"),
+    );
+    const original = fs.readFileSync(TOKEN_LIST, "utf8");
+    fs.writeFileSync(TOKEN_LIST, applyEnrichment(original, enrichment));
+}
+
+module.exports = { applyEnrichment };

script/lib/enrich-tokens.js

@@ -0,0 +1,115 @@
+// Fetches a name and a website for every token in src/shared/tokenList.js and
+// writes them, keyed by address, to script/lib/token-enrichment.json, which
+// script/lib/apply-enrichment.js then writes into tokenList.js. Run by
+// `make enrich-tokens`; no build runs it and nothing here is shipped.
+//
+// Names come from CoinGecko's coin list, fetched whole in one request, matched
+// on the token's Ethereum contract address. A token CoinGecko does not list
+// gets its symbol as its name. The list is live data with no fixed version, so
+// a later run can return different names.
+//
+// Websites come from the ethereum-lists/tokens repository, one file per token,
+// read at a pinned commit. Most tokens have no file there and get an empty URL.
+// A file that is missing is not an error; any other failed request stops the
+// run, so a network fault cannot quietly empty a URL.
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const TOKEN_LIST = path.join(__dirname, "..", "..", "src/shared/tokenList.js");
+const OUTPUT = path.join(__dirname, "token-enrichment.json");
+
+const COINGECKO_LIST =
+    "https://api.coingecko.com/api/v3/coins/list?include_platform=true";
+// ethereum-lists/tokens at its master of 2026-02-27, when the committed
+// token-enrichment.json was made.
+const ETHEREUM_LISTS =
+    "https://raw.githubusercontent.com/ethereum-lists/tokens/c3560d499a380a38e94caa7c4968d59aeffde59a/tokens/eth";
+
+const CONCURRENT = 10;
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function main() {
+    const src = fs.readFileSync(TOKEN_LIST, "utf8");
+
+    const tokens = [];
+    const re =
+        /\{\s*address:\s*"(0x[a-fA-F0-9]{40})",\s*symbol:\s*"([^"]+)",\s*decimals:\s*(\d+)/g;
+    let m;
+    while ((m = re.exec(src)) !== null) {
+        tokens.push({ address: m[1], symbol: m[2], decimals: parseInt(m[3]) });
+    }
+    console.error(`Parsed ${tokens.length} tokens`);
+
+    // --- Names from CoinGecko ---
+    console.error("Fetching CoinGecko coins list...");
+    const listResp = await fetch(COINGECKO_LIST);
+    if (!listResp.ok) throw new Error(`CoinGecko list HTTP ${listResp.status}`);
+    const coins = await listResp.json();
+
+    const addrMap = new Map();
+    for (const coin of coins) {
+        const eth = (coin.platforms?.ethereum || "").toLowerCase().trim();
+        if (eth && eth.startsWith("0x")) {
+            addrMap.set(eth, { name: coin.name, id: coin.id });
+        }
+    }
+    console.error(`CoinGecko map: ${addrMap.size} Ethereum tokens`);
+
+    const enriched = new Map();
+    let namesMatched = 0;
+    for (const t of tokens) {
+        const info = addrMap.get(t.address.toLowerCase());
+        if (info) namesMatched++;
+        enriched.set(t.address, { name: info?.name || t.symbol, url: "" });
+    }
+    console.error(`Matched ${namesMatched}/${tokens.length} names`);
+
+    // --- Websites from ethereum-lists ---
+    console.error("Fetching URLs from ethereum-lists GitHub...");
+    let urlsFound = 0;
+
+    for (let i = 0; i < tokens.length; i += CONCURRENT) {
+        const batch = tokens.slice(i, i + CONCURRENT);
+        await Promise.all(
+            batch.map(async (t) => {
+                const r = await fetch(`${ETHEREUM_LISTS}/${t.address}.json`);
+                if (r.status === 404) return;
+                if (!r.ok) {
+                    throw new Error(
+                        `ethereum-lists HTTP ${r.status} for ${t.address}`,
+                    );
+                }
+                const data = await r.json();
+                const website = (data.website || "").trim();
+                if (website && website !== "https://") {
+                    enriched.get(t.address).url = website;
+                    urlsFound++;
+                }
+            }),
+        );
+        if (i % 100 === 0) {
+            console.error(
+                `  GitHub: ${Math.min(i + CONCURRENT, tokens.length)}/${tokens.length}, ${urlsFound} URLs`,
+            );
+        }
+        await sleep(200);
+    }
+    console.error(`Found ${urlsFound} URLs in ethereum-lists`);
+
+    // --- Output, in the layout prettier gives it ---
+    const output = {};
+    for (const [addr, e] of enriched) {
+        output[addr] = { name: e.name, url: e.url };
+    }
+    fs.writeFileSync(OUTPUT, JSON.stringify(output, null, 4) + "\n");
+    console.error(`Done! ${tokens.length} names, ${urlsFound} URLs.`);
+}
+
+main().catch((err) => {
+    console.error(`enrich-tokens: ${err.message}`);
+    process.exit(1);
+});

script/test-e2e

@@ -22,13 +22,29 @@ set -eu
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
 
-IMAGE="$("$SCRIPT_DIR/projectname")-e2e-chrome"
-
-IIDFILE=""
+# Each run builds, runs and then removes an image under a tag of its own.
+# Under one tag shared by every run, a second clone's build moves the tag
+# off this run's image, and the image store can then delete that untagged
+# image before or while this run uses it. The tag is random rather than
+# $$ because CI jobs share one docker daemon, but each job's container
+# numbers its processes from scratch.
+SUFFIX="$(od -An -N6 -tx1 /dev/urandom | tr -d ' \n')"
+NAME="$("$SCRIPT_DIR/projectname")-e2e-chrome"
+IMAGE="$NAME:$SUFFIX"
+# Each docker run below uses this container name: docker run --rm returns
+# only once its container is removed, so no run meets the one before it.
+CONTAINER="$NAME-$SUFFIX"
 
 cleanup() {
-    if [ -n "$IIDFILE" ]; then
-        rm -f "$IIDFILE"
+    # After a third Ctrl-C docker's client exits whether or not the
+    # container has stopped, and a container still running keeps the image
+    # in use.
+    if docker container inspect "$CONTAINER" >/dev/null 2>&1; then
+        docker container rm -f "$CONTAINER" >/dev/null
+    fi
+    # No image to remove when the build failed or was interrupted.
+    if docker image inspect "$IMAGE" >/dev/null 2>&1; then
+        docker image rm "$IMAGE" >/dev/null
     fi
 }
 
@@ -40,22 +56,16 @@ main() {
         exit 1
     fi
 
-    IIDFILE="$(mktemp)"
     trap cleanup EXIT
-    trap 'cleanup; exit 130' INT TERM
+    # HUP: the terminal or SSH session running the suite closed.
+    trap 'cleanup; exit 130' HUP INT TERM
 
     echo "Building the Chrome e2e image (extension included)..."
     # --no-cache: the image build runs make build and its checks, and a
     # cached layer is a check that did not run.
-    docker build --no-cache --iidfile "$IIDFILE" -t "$IMAGE" \
-        -f tests/e2e/Dockerfile .
+    docker build --no-cache -t "$IMAGE" -f tests/e2e/Dockerfile .
 
     echo "Running e2e suite in the pinned Playwright container..."
-    # The image is run by ID, not by tag: where two clones of this repo run
-    # the suite at once, the other build can move the tag between this
-    # build and this run, and the suite would then silently test the other
-    # checkout.
-    #
     # --ipc=host: Chromium's shared-memory needs more than the default
     #   64MB /dev/shm or renderers crash.
     # HOME=/tmp: the image's root home is not a reliable place for the
@@ -75,11 +85,12 @@ main() {
     #   probe. The image is pinned by digest, so this can only ever bite
     #   on a deliberate bump.
     docker run --rm \
+        --name "$CONTAINER" \
         --ipc=host \
         -e HOME=/tmp \
         -e PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS=1 \
         -e "E2E_TRACE_NETWORK=${E2E_TRACE_NETWORK:-0}" \
-        "$(cat "$IIDFILE")" \
+        "$IMAGE" \
         node tests/e2e/run.js
 
     # Where chrome.storage.local lives, and what moves it: two unpacked loads
@@ -93,10 +104,24 @@ main() {
     # --host-resolver-rules=MAP * ~NOTFOUND so nothing it does can leave.
     echo "Running the extension-id and storage-partition observations..."
     docker run --rm \
+        --name "$CONTAINER" \
         --ipc=host \
         -e HOME=/tmp \
-        "$(cat "$IIDFILE")" \
+        "$IMAGE" \
         node tests/e2e/storagePartition.js
+
+    # Approvals left open for seven minutes in minimized windows, past the
+    # point where Chrome stopped the background worker when nothing kept it
+    # running. Its own program, without Playwright: Playwright keeps DevTools
+    # attached to the worker, and Chrome never stops a worker DevTools is
+    # attached to. It reaches nothing but its own loopback server.
+    echo "Running the approvals left open for seven minutes..."
+    docker run --rm \
+        --name "$CONTAINER" \
+        --ipc=host \
+        -e HOME=/tmp \
+        "$IMAGE" \
+        node tests/e2e/slowApproval.js
 }
 
 main "$@"

script/test-e2e-firefox

@@ -21,13 +21,23 @@ set -eu
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
 
-IMAGE="$("$SCRIPT_DIR/projectname")-e2e-firefox"
-
-IIDFILE=""
+# A tag and a container name of this run's own, as in script/test-e2e,
+# which says why.
+SUFFIX="$(od -An -N6 -tx1 /dev/urandom | tr -d ' \n')"
+NAME="$("$SCRIPT_DIR/projectname")-e2e-firefox"
+IMAGE="$NAME:$SUFFIX"
+CONTAINER="$NAME-$SUFFIX"
 
 cleanup() {
-    if [ -n "$IIDFILE" ]; then
-        rm -f "$IIDFILE"
+    # After a third Ctrl-C docker's client exits whether or not the
+    # container has stopped, and a container still running keeps the image
+    # in use.
+    if docker container inspect "$CONTAINER" >/dev/null 2>&1; then
+        docker container rm -f "$CONTAINER" >/dev/null
+    fi
+    # No image to remove when the build failed or was interrupted.
+    if docker image inspect "$IMAGE" >/dev/null 2>&1; then
+        docker image rm "$IMAGE" >/dev/null
     fi
 }
 
@@ -39,22 +49,16 @@ main() {
         exit 1
     fi
 
-    IIDFILE="$(mktemp)"
     trap cleanup EXIT
-    trap 'cleanup; exit 130' INT TERM
+    # HUP: the terminal or SSH session running the suite closed.
+    trap 'cleanup; exit 130' HUP INT TERM
 
     echo "Building the pinned Firefox e2e image (extension included)..."
     # --no-cache: the image build runs make build and its checks, and a
     # cached layer is a check that did not run.
-    docker build --no-cache --iidfile "$IIDFILE" -t "$IMAGE" \
-        -f tests/e2e/firefox/Dockerfile .
+    docker build --no-cache -t "$IMAGE" -f tests/e2e/firefox/Dockerfile .
 
     echo "Running the Firefox e2e suite..."
-    # The image is run by ID, not by tag: where two clones of this repo run
-    # the suite at once, the other build can move the tag between this
-    # build and this run, and the suite would then silently test the other
-    # checkout.
-    #
     # --shm-size=1g: Firefox needs more than the default 64MB /dev/shm.
     # --network none: the suite stubs nothing, so this is what keeps the
     #   run offline and deterministic. The extension swallows its own
@@ -69,10 +73,11 @@ main() {
     # "CanCreateUserNamespace() clone() failure: EPERM" on startup here;
     # it is cosmetic and headless Firefox runs fine without it.
     docker run --rm \
+        --name "$CONTAINER" \
         --shm-size=1g \
         --network none \
         -e HOME=/tmp \
-        "$(cat "$IIDFILE")" \
+        "$IMAGE" \
         node tests/e2e/firefox/run.js dist/firefox
 
     # The install/uninstall/re-install property, against the packaged XPI
@@ -82,10 +87,11 @@ main() {
     # and the suite above shares one session throughout.
     echo "Running the Firefox re-install suite against the packaged XPI..."
     docker run --rm \
+        --name "$CONTAINER" \
         --shm-size=1g \
         --network none \
         -e HOME=/tmp \
-        "$(cat "$IIDFILE")" \
+        "$IMAGE" \
         node tests/e2e/firefox/reinstall.js
 }
 

src/background/index.js

@@ -22,8 +22,11 @@ const { debugFetch, log } = require("../shared/log");
 const {
     verifySignedTx,
     verifySignature,
+    signedPrimaryType,
+    typedDataMessageRefusal,
     typedDataChainRefusal,
     failureIsRetryable,
+    nodeError,
     describeTxFailure,
     sameAddress,
     ApprovalMismatchError,
@@ -44,7 +47,11 @@ const {
 
 const {
     actionApi,
+    getPlatformInfo,
     runtimeApi,
+    sessionStorageGet,
+    sessionStorageRemove,
+    sessionStorageSet,
     tabsQuery,
     tabsSendMessage,
     windowsApi,
@@ -57,16 +64,62 @@ const runtime = runtimeApi();
 const windowsNs = windowsApi();
 const actionNs = actionApi();
 
-// Connected sites (in-memory, non-persisted): { "origin:address": true }
+// Connections the user allowed without "Remember my choice for this site".
+// Each is one item in the browser's session storage, key
+// origin + ":" + address and value true, and session storage holds nothing
+// else. Session storage outlives this worker being stopped when idle and
+// started again, so such a connection lasts until it is ended below or the
+// browser closes. One item per connection means that making one is a single
+// write, and two never overwrite each other.
 //
 // A site is its full origin (scheme://host[:port]), here and in the
 // remembered allowedSites/deniedSites lists alike: a grant to
 // https://dapp.example says nothing about http://dapp.example or another port.
-const connectedSites = {};
+// An origin can carry a port, so the address is what follows the key's last
+// colon and the origin is what precedes it.
+async function isConnected(origin, address) {
+    const key = origin + ":" + address;
+    const items = await sessionStorageGet(key);
+    return items[key] === true;
+}
+
+// End every connection allowed without "Remember" whose key `ends` returns
+// true for.
+async function endConnections(ends) {
+    const keys = Object.keys(await sessionStorageGet(null)).filter(ends);
+    if (keys.length > 0) await sessionStorageRemove(keys);
+}
 
 // Pending approval requests: { id: { origin, resolve } }
 const pendingApprovals = {};
 
+// An approval, and the site's request waiting on it, exist only in this
+// worker's memory. Left alone, Chrome stopped the worker about six minutes
+// after the site's request while the user was still deciding, and the approval
+// was lost with it. Chrome counts an extension call as activity, so while any
+// approval is pending this worker makes one every 20 seconds, inside Chrome's
+// 30-second idle limit. It is the worker's own timer, so it runs whether or not
+// the approval window is visible, and it stops itself once nothing is pending.
+let keepRunningTimer = null;
+
+// Add an approval waiting for the user, and start the timer above if it is not
+// running. This is the ONLY place an approval is added, as settleApproval() is
+// the only place one is removed, so every kind of approval keeps the worker
+// running while it waits.
+function addPendingApproval(approval) {
+    pendingApprovals[approval.id] = approval;
+    if (keepRunningTimer) return;
+    keepRunningTimer = setInterval(() => {
+        if (Object.keys(pendingApprovals).length === 0) {
+            clearInterval(keepRunningTimer);
+            keepRunningTimer = null;
+            return;
+        }
+        // Only the call matters; its answer is not used.
+        getPlatformInfo().catch(() => {});
+    }, 20000);
+}
+
 // One transaction approval at a time, wallet-wide.
 //
 // The transaction a site asks for is populated before its approval window
@@ -242,6 +295,21 @@ function failureError(err) {
     return { code: INTERNAL_ERROR_CODE, message: INTERNAL_ERROR_MESSAGE };
 }
 
+// The EIP-1193 error for a request that failed, with `message` as the
+// sentence the page is shown. `rpcError` holds the JSON-RPC code and data the
+// failure carries, if any: the node's own when the node refused the request,
+// passed on unchanged so a site can tell a revert from any other failure and
+// decode its revert data. A failure with no numeric code is the wallet's own,
+// and is answered with the internal error code above.
+function requestError(message, rpcError) {
+    if (rpcError && typeof rpcError.code === "number") {
+        const error = { code: rpcError.code, message };
+        if (rpcError.data !== undefined) error.data = rpcError.data;
+        return error;
+    }
+    return { code: INTERNAL_ERROR_CODE, message };
+}
+
 // The active address of a profile snapshot. Pure, and taking the snapshot as
 // an argument rather than reading storage itself: a handler that has already
 // read state must not answer "which account is this" from a SECOND, later read
@@ -287,7 +355,8 @@ function extractHostname(origin) {
     }
 }
 
-// Proxy an RPC call to the Ethereum node
+// Proxy an RPC call to the Ethereum node. An error the node answers with is
+// thrown with the node's own JSON-RPC `code` and `data` on it, for the page.
 async function proxyRpc(method, params) {
     const rpcUrl = await getRpcUrl();
     const resp = await debugFetch(rpcUrl, {
@@ -302,7 +371,10 @@ async function proxyRpc(method, params) {
     });
     const json = await resp.json();
     if (json.error) {
-        throw new Error(json.error.message || "RPC error");
+        const err = new Error(json.error.message || "RPC error");
+        err.code = json.error.code;
+        err.data = json.error.data;
+        throw err;
     }
     return json.result;
 }
@@ -423,7 +495,10 @@ function releaseApproval(approval) {
 // the result on the floor, so a rejection here would be unhandled.
 async function openApprovalWindow(id) {
     const popupUrl = runtime.getURL("src/popup/index.html?approval=" + id);
-    const popupWidth = 360;
+    // As wide as the page: body in src/popup/styles/main.css. The browser
+    // counts the window's frame in this width; the page itself adds back
+    // whatever the frame takes (src/popup/index.js).
+    const popupWidth = 396;
     const popupHeight = 600;
 
     let currentWin = null;
@@ -443,7 +518,7 @@ async function openApprovalWindow(id) {
     // Centred on a browser window only. The last focused window can be
     // another approval window still open, and centring on one can give a
     // position the browser refuses ("Bounds must be at least 50% within
-    // visible screen space"): headless Chrome reports this 360x600 popup as
+    // visible screen space"): headless Chrome reports this 396x600 popup as
     // 1280x720. The request then failed with no window at all. Over a popup,
     // the browser picks the position.
     if (currentWin && currentWin.type === "normal") {
@@ -514,7 +589,7 @@ async function openApprovalWindow(id) {
 function requestApproval(origin) {
     return new Promise((resolve) => {
         const id = crypto.randomUUID();
-        pendingApprovals[id] = { id, origin, resolve, type: "site" };
+        addPendingApproval({ id, origin, resolve, type: "site" });
 
         if (actionNs && typeof actionNs.openPopup === "function") {
             showInToolbarPopup(id);
@@ -557,14 +632,14 @@ function showInToolbarPopup(id) {
 function requestTxApproval(origin, approvedTx, approvedFrom, slot) {
     return new Promise((resolve) => {
         const id = crypto.randomUUID();
-        pendingApprovals[id] = {
+        addPendingApproval({
             id,
             origin,
             approvedTx,
             approvedFrom,
             resolve,
             type: "tx",
-        };
+        });
         if (slot) slot.approvalId = id;
 
         openApprovalWindow(id);
@@ -578,14 +653,14 @@ function requestTxApproval(origin, approvedTx, approvedFrom, slot) {
 function requestSignApproval(origin, signParams, approvedFrom) {
     return new Promise((resolve) => {
         const id = crypto.randomUUID();
-        pendingApprovals[id] = {
+        addPendingApproval({
             id,
             origin,
             signParams,
             approvedFrom,
             resolve,
             type: "sign",
-        };
+        });
 
         openApprovalWindow(id);
     });
@@ -598,14 +673,14 @@ function requestSignApproval(origin, signParams, approvedFrom) {
 function requestNetworkApproval(origin, currentNetworkId, requestedNetworkId) {
     return new Promise((resolve) => {
         const id = crypto.randomUUID();
-        pendingApprovals[id] = {
+        addPendingApproval({
             id,
             origin,
             currentNetworkId,
             requestedNetworkId,
             resolve,
             type: "network",
-        };
+        });
 
         openApprovalWindow(id);
     });
@@ -695,7 +770,7 @@ async function handleConnectionRequest(origin) {
     const s = await getState();
     const activeAddress = activeAddressOf(s);
     if (!activeAddress) {
-        return { error: { message: "No accounts available" } };
+        return { error: { code: 4100, message: "No accounts available" } };
     }
 
     const allowed = s.allowedSites[activeAddress] || [];
@@ -711,10 +786,10 @@ async function handleConnectionRequest(origin) {
         };
     }
 
-    // Check allowed list or in-memory connected
+    // Check allowed list or a connection allowed without "Remember"
     if (
         allowed.includes(origin) ||
-        connectedSites[origin + ":" + activeAddress]
+        (await isConnected(origin, activeAddress))
     ) {
         return { result: [activeAddress] };
     }
@@ -751,7 +826,7 @@ async function handleConnectionRequest(origin) {
         if (decision.remember) {
             await rememberSiteChoice("allowedSites", activeAddress, origin);
         } else {
-            connectedSites[origin + ":" + activeAddress] = true;
+            await sessionStorageSet({ [origin + ":" + activeAddress]: true });
         }
         return { result: [activeAddress] };
     } else {
@@ -805,7 +880,7 @@ async function handleRpc(method, params, origin) {
         const allowed = s.allowedSites[activeAddress] || [];
         if (
             allowed.includes(origin) ||
-            connectedSites[origin + ":" + activeAddress]
+            (await isConnected(origin, activeAddress))
         ) {
             return { result: [activeAddress] };
         }
@@ -841,7 +916,7 @@ async function handleRpc(method, params, origin) {
         const allowed = s.allowedSites[activeAddress] || [];
         if (
             !allowed.includes(origin) &&
-            !connectedSites[origin + ":" + activeAddress]
+            !(await isConnected(origin, activeAddress))
         ) {
             return { error: { code: 4100, message: "Unauthorized" } };
         }
@@ -934,10 +1009,10 @@ async function handleRpc(method, params, origin) {
         const s = await getState();
         const activeAddress = activeAddressOf(s);
         const allowed = s.allowedSites[activeAddress] || [];
-        const isConnected =
+        const hasPermission =
             allowed.includes(origin) ||
-            connectedSites[origin + ":" + activeAddress];
-        if (!isConnected || !activeAddress) {
+            (await isConnected(origin, activeAddress));
+        if (!hasPermission || !activeAddress) {
             return { result: [] };
         }
         return {
@@ -959,12 +1034,12 @@ async function handleRpc(method, params, origin) {
         const s = await getState();
         const activeAddress = activeAddressOf(s);
         if (!activeAddress)
-            return { error: { message: "No accounts available" } };
+            return { error: { code: 4100, message: "No accounts available" } };
 
         const allowed = s.allowedSites[activeAddress] || [];
         if (
             !allowed.includes(origin) &&
-            !connectedSites[origin + ":" + activeAddress]
+            !(await isConnected(origin, activeAddress))
         ) {
             return { error: { code: 4100, message: "Unauthorized" } };
         }
@@ -988,9 +1063,8 @@ async function handleRpc(method, params, origin) {
 
         if (method === "eth_sign") {
             signParams.dangerWarning =
-                "\u26a0\ufe0f DANGER: This site is requesting to sign a raw hash. " +
-                "This can be used to sign transactions that drain your funds. " +
-                "Only proceed if you fully understand what you are signing.";
+                "This site used the older eth_sign method. " +
+                "The data will be signed as a personal message.";
         }
 
         if (findPendingApproval(origin, "sign")) {
@@ -1014,12 +1088,12 @@ async function handleRpc(method, params, origin) {
         const s = await getState();
         const activeAddress = activeAddressOf(s);
         if (!activeAddress)
-            return { error: { message: "No accounts available" } };
+            return { error: { code: 4100, message: "No accounts available" } };
 
         const allowed = s.allowedSites[activeAddress] || [];
         if (
             !allowed.includes(origin) &&
-            !connectedSites[origin + ":" + activeAddress]
+            !(await isConnected(origin, activeAddress))
         ) {
             return { error: { code: 4100, message: "Unauthorized" } };
         }
@@ -1061,12 +1135,13 @@ async function handleRpc(method, params, origin) {
             const result = await proxyRpc(method, params);
             return { result };
         } catch (e) {
-            // A node that answered with an error is reported as itself. The
-            // wallet being unable to read its own profile is not that, and it
-            // must not be flattened into a message with no code: it goes back
-            // to the dispatcher, which has the one answer for it.
+            // A node that answered with an error is reported as itself, with
+            // its own code and data. The wallet being unable to read its own
+            // profile is not that, and it must not be answered as an ordinary
+            // failure: it goes back to the dispatcher, which has the one
+            // answer for it.
             if (e instanceof StateUnusableError) throw e;
-            return { error: { message: e.message } };
+            return { error: requestError(e.message, e) };
         }
     }
 
@@ -1082,12 +1157,14 @@ async function handleRpc(method, params, origin) {
 async function handleSendTransaction(params, origin) {
     const s = await getState();
     const activeAddress = activeAddressOf(s);
-    if (!activeAddress) return { error: { message: "No accounts available" } };
+    if (!activeAddress) {
+        return { error: { code: 4100, message: "No accounts available" } };
+    }
 
     const allowed = s.allowedSites[activeAddress] || [];
     if (
         !allowed.includes(origin) &&
-        !connectedSites[origin + ":" + activeAddress]
+        !(await isConnected(origin, activeAddress))
     ) {
         return { error: { code: 4100, message: "Unauthorized" } };
     }
@@ -1141,7 +1218,7 @@ async function handleSendTransaction(params, origin) {
                 txParams,
             );
         } catch (e) {
-            return { error: { message: e.message } };
+            return { error: requestError(e.message, e) };
         }
 
         // Population is a network round trip, and the user can switch address
@@ -1151,10 +1228,9 @@ async function handleSendTransaction(params, origin) {
         // while the page is still waiting and nothing has been displayed.
         if (!sameAddress(await getActiveAddress(), activeAddress)) {
             return {
-                error: {
-                    message:
-                        "The active address changed while this transaction was being prepared, so it was not sent.",
-                },
+                error: requestError(
+                    "The active address changed while this transaction was being prepared, so it was not sent.",
+                ),
             };
         }
 
@@ -1200,10 +1276,6 @@ async function broadcastChainChanged(chainId) {
 
 // Broadcast accountsChanged to all tabs, respecting per-address permissions
 async function broadcastAccountsChanged() {
-    // Clear non-remembered approvals on address switch
-    for (const key of Object.keys(connectedSites)) {
-        delete connectedSites[key];
-    }
     // Reject and close any pending approval popups so they don't hang. An
     // approval an attempt has already claimed is left alone entirely: it is
     // being signed and broadcast right now, and neither rejecting it to the
@@ -1222,6 +1294,10 @@ async function broadcastAccountsChanged() {
         }
     }
     resetPopupUrl();
+    // An address switch ends every connection allowed without "Remember". This
+    // waits on storage, so it comes after the pending approvals above, which
+    // are still rejected the moment the switch arrives.
+    await endConnections(() => true);
     const s = await getState();
     const activeAddress = activeAddressOf(s);
     const allowed = activeAddress ? s.allowedSites[activeAddress] || [] : [];
@@ -1232,17 +1308,24 @@ async function broadcastAccountsChanged() {
         return;
     }
     for (const tab of tabs) {
+        // The tab's URL is all the background knows of the page in it, and a
+        // page at a site's URL may have another origin: a page its server
+        // sandboxes with a Content-Security-Policy has the origin "null". So
+        // the event names the origin it was judged by, and the content script
+        // passes the address on only to a page whose own origin is that one
+        // (src/content/index.js).
         const origin = tab.url ? new URL(tab.url).origin : "";
         const hasPermission =
             activeAddress &&
             (allowed.includes(origin) ||
-                connectedSites[origin + ":" + activeAddress]);
+                (await isConnected(origin, activeAddress)));
         // Same as chainChanged above: a tab without our content script
         // rejects, and that is expected rather than a fault.
         tabsSendMessage(tab.id, {
             type: "AUTISTMASK_EVENT",
             eventName: "accountsChanged",
             data: hasPermission ? [activeAddress] : [],
+            origin,
         }).catch(() => {});
     }
 }
@@ -1428,7 +1511,14 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
         // the message carries. Firefox before 126 gives no sender.origin, so
         // the origin of sender.url is used: the frame that sent the message,
         // not the tab's page, which may be another site embedding that
-        // frame. With neither, the request is refused.
+        // frame.
+        //
+        // A site is scheme://host[:port], so a request is refused when its
+        // origin has no host, as when it has no origin at all, rather than
+        // credited to the site its URL names. The browser reports "null" for
+        // a page with an opaque origin, such as one its server sandboxes with
+        // a Content-Security-Policy, and Chrome reports "file://" for a local
+        // file.
         let trustedOrigin = sender.origin;
         if (!trustedOrigin && sender.url) {
             try {
@@ -1437,7 +1527,13 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
                 // an unparseable URL leaves the origin unknown
             }
         }
-        if (!trustedOrigin) {
+        let host = "";
+        try {
+            host = new URL(trustedOrigin).host;
+        } catch {
+            // no origin, or "null", is not a URL and so has no host
+        }
+        if (!host) {
             sendResponse({
                 error: {
                     code: 4100,
@@ -1634,7 +1730,7 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
                 if (outcome.spendApproval) {
                     settleApproval(
                         msg.id,
-                        { error: { message: outcome.error } },
+                        { error: requestError(outcome.error) },
                         { holdsClaim: true },
                     );
                 } else {
@@ -1661,7 +1757,7 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
                 const outcome = describeTxFailure(TX_STAGE_NONCE, null);
                 settleApproval(
                     msg.id,
-                    { error: { message: outcome.error } },
+                    { error: requestError(outcome.error) },
                     { holdsClaim: true },
                 );
                 sendResponse({
@@ -1694,10 +1790,13 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
                 // that says plainly it did not take the transaction:
                 // describeTxFailure() reclassifies that, and the stage it
                 // returns is the one reported.
+                //
+                // A node that refused the transaction gives the page its own
+                // code and data, whatever sentence the page is shown.
                 const outcome = describeTxFailure(TX_STAGE_BROADCAST, e);
                 settleApproval(
                     msg.id,
-                    { error: { message: outcome.error } },
+                    { error: requestError(outcome.error, nodeError(e)) },
                     { holdsClaim: true },
                 );
                 sendResponse({
@@ -1788,18 +1887,27 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
                     signature,
                     approval.approvedFrom,
                 );
-                // 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.
+                // 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.
                 const sp = approval.signParams;
                 if (
                     sp.method === "eth_signTypedData_v4" ||
                     sp.method === "eth_signTypedData"
                 ) {
-                    const refusal = typedDataChainRefusal(
-                        JSON.parse(sp.typedData).domain,
-                        networkById(s.networkId),
-                    );
+                    const data = JSON.parse(sp.typedData);
+                    const refusal =
+                        typedDataMessageRefusal(
+                            data.types,
+                            signedPrimaryType(data.types),
+                            data.message,
+                            "",
+                        ) ||
+                        typedDataChainRefusal(
+                            data.domain,
+                            networkById(s.networkId),
+                        );
                     if (refusal) throw new ApprovalMismatchError(refusal);
                 }
                 settleApproval(msg.id, { signature }, { holdsClaim: true });
@@ -1810,7 +1918,7 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
                 if (!retryable) {
                     settleApproval(
                         msg.id,
-                        { error: { message: errMsg } },
+                        { error: requestError(errMsg) },
                         { holdsClaim: true },
                     );
                 } else {
@@ -1838,41 +1946,57 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
     }
 
     // The popup removed these addresses, so no site stays connected to them.
-    // A connectedSites key is origin + ":" + address, and an origin can carry
-    // a port, so the address is what follows the last colon.
     if (msg.type === "AUTISTMASK_ADDRESSES_REMOVED") {
         const removed = Array.isArray(msg.addresses) ? msg.addresses : [];
-        for (const key of Object.keys(connectedSites)) {
+        endConnections((key) => {
             const address = key.slice(key.lastIndexOf(":") + 1);
-            if (removed.some((a) => sameAddress(a, address))) {
-                delete connectedSites[key];
-            }
-        }
+            return removed.some((a) => sameAddress(a, address));
+        }).catch((err) => {
+            log.errorf(
+                "ending the removed addresses' connections failed:",
+                err,
+            );
+        });
         return false;
     }
 
-    // Settings lists the sites connected without "Remember", which only this
-    // worker knows. The origin is what precedes the key's last colon.
+    // Settings lists the sites connected without "Remember", which only
+    // session storage holds.
     if (msg.type === "AUTISTMASK_GET_CONNECTED_SITES") {
-        sendResponse(
-            Object.keys(connectedSites).map((key) =>
-                key.slice(0, key.lastIndexOf(":")),
-            ),
-        );
-        return false;
+        sessionStorageGet(null)
+            .then((items) =>
+                Object.keys(items).map((key) =>
+                    key.slice(0, key.lastIndexOf(":")),
+                ),
+            )
+            .catch((err) => {
+                log.errorf("listing the connected sites failed:", err);
+                return [];
+            })
+            .then(sendResponse);
+        return true;
     }
 
     // Settings removed this site (msg.origin) and has already dropped its
     // remembered entries. Its connections approved without "Remember" end
     // here, under every address, and its open tabs are told it has no account.
+    // The answer goes back once they have ended, and Settings waits for it
+    // before it lists the connected sites again.
     if (msg.type === "AUTISTMASK_REMOVE_SITE") {
-        for (const key of Object.keys(connectedSites)) {
-            if (key.slice(0, key.lastIndexOf(":")) === msg.origin) {
-                delete connectedSites[key];
-            }
-        }
-        broadcastSiteRemoved(msg.origin);
-        return false;
+        endConnections(
+            (key) => key.slice(0, key.lastIndexOf(":")) === msg.origin,
+        )
+            .catch((err) => {
+                log.errorf(
+                    "ending the removed site's connections failed:",
+                    err,
+                );
+            })
+            .then(() => {
+                broadcastSiteRemoved(msg.origin);
+                sendResponse(null);
+            });
+        return true;
     }
 
     // Settings switched the network and has saved it. Open tabs are told the

src/content/index.js

@@ -49,14 +49,23 @@ window.addEventListener("message", (event) => {
 
 // Listen for events pushed from the background (e.g. accountsChanged)
 runtimeApi().onMessage.addListener((msg) => {
-    if (msg.type === "AUTISTMASK_EVENT") {
-        window.postMessage(
-            {
-                type: "AUTISTMASK_EVENT",
-                eventName: msg.eventName,
-                data: msg.data,
-            },
-            "*",
-        );
+    if (msg.type !== "AUTISTMASK_EVENT") return;
+    // The background chooses the addresses in accountsChanged for the site
+    // at the origin the event names, which is the origin of the tab's URL.
+    // This page hears them only when its own origin is that one. A page whose
+    // origin has no host is not a site: one its server sandboxes with a
+    // Content-Security-Policy has the origin "null" whatever its URL, and is
+    // told no address, as its requests are refused.
+    let data = msg.data;
+    if (msg.eventName === "accountsChanged" && msg.origin !== window.origin) {
+        data = [];
     }
+    window.postMessage(
+        {
+            type: "AUTISTMASK_EVENT",
+            eventName: msg.eventName,
+            data,
+        },
+        "*",
+    );
 });

src/popup/index.html

@@ -1716,10 +1716,7 @@
                     <div class="text-xs text-muted mb-1">
                         Address that will be shared:
                     </div>
-                    <div
-                        id="approve-address"
-                        class="text-xs flex items-center mb-2"
-                    ></div>
+                    <div id="approve-address" class="text-xs mb-2"></div>
                 </div>
                 <div class="mb-3">
                     <label

src/popup/index.js

@@ -21,6 +21,12 @@ const {
     goBack,
 } = require("./views/helpers");
 const { applyTheme } = require("./theme");
+const {
+    tabsGetCurrent,
+    tabsGetZoom,
+    windowsGetCurrent,
+    windowsUpdate,
+} = require("../shared/browserApi");
 // Renders a view the popup lands on without having navigated to it forward:
 // on restore here, and on Back. Only the views that can be fully re-rendered
 // from persisted state (RESTORABLE_VIEWS, src/shared/restorableViews.js) go
@@ -163,6 +169,40 @@ function fallbackView() {
     showView("main");
 }
 
+// The background opens the approval window as wide as the page, but the
+// browser counts the window's frame in that width, and a screen taller than
+// the window takes a vertical scrollbar out of it too. So once the screen is
+// up, the window is widened by however far the page would scroll sideways.
+// That distance is in page pixels and the window's width in screen pixels:
+// at 150% zoom one page pixel is 1.5 screen pixels. The zoom is read for this
+// page's own tab, because asked without a tab id Firefox answers for the
+// window focused last. Firefox draws some zoom steps a little larger than the
+// zoom it reports, 170% among them, so once the page has its new width (its
+// resize event) it is measured again, and the window widened again while the
+// page still falls short, three times at most. A window that cannot grow sends
+// no resize event, and the page stops there. The connection prompt can also
+// show in the toolbar popup, whose window is the user's browser window; that
+// one is left alone.
+async function widenApprovalWindow() {
+    const page = document.documentElement;
+    if (page.scrollWidth <= page.clientWidth) return;
+    const win = await windowsGetCurrent();
+    if (win.type !== "popup") return;
+    const tab = await tabsGetCurrent();
+    const zoom = await tabsGetZoom(tab.id);
+    let width = win.width;
+    for (let tries = 0; tries < 3; tries++) {
+        const sideways = page.scrollWidth - page.clientWidth;
+        if (sideways <= 0) return;
+        width += Math.ceil(sideways * zoom);
+        const resized = new Promise((resolve) =>
+            window.addEventListener("resize", resolve, { once: true }),
+        );
+        await windowsUpdate(win.id, { width });
+        await resized;
+    }
+}
+
 async function init() {
     // First, before anything can save: showView() saves on every navigation
     // without awaiting, so a save that fails from here on has somewhere to be
@@ -239,8 +279,8 @@ async function init() {
         // the run on both harnesses (Playwright `pageerror`, and the Firefox
         // driver's console-service drain), so nothing is lost by leaving it
         // on that path. show() puts the approval's own screen up once the
-        // background has described it.
-        approval.show(approvalId);
+        // background has described it; the window is widened to fit it then.
+        approval.show(approvalId).then(widenApprovalWindow);
         return;
     }
 

src/popup/views/addWallet.js

@@ -20,6 +20,7 @@ const {
 const { encryptWithPassword } = require("../../shared/vault");
 const { state, saveState } = require("../../shared/state");
 const { scanForAddresses } = require("../../shared/balances");
+const { notify } = require("../../shared/browserApi");
 
 /**
  * Check if an address already exists in ANY wallet (hd, xprv, or key).
@@ -184,11 +185,19 @@ async function importMnemonic(ctx) {
         encryptedSecret: encrypted,
         nextIndex: 1,
         addresses: [
-            { address: firstAddress, balance: "0.0000", tokenBalances: [] },
+            {
+                address: firstAddress,
+                index: 0,
+                balance: "0.0000",
+                tokenBalances: [],
+            },
         ],
     };
     state.wallets.push(wallet);
     state.hasWallet = true;
+    if (state.activeAddress === null) {
+        state.activeAddress = firstAddress;
+    }
     await saveState();
     clearViewStack();
     ctx.renderWalletList();
@@ -205,12 +214,21 @@ 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: [],
         }));
         wallet.nextIndex = scan.nextIndex;
+        // The new list leaves out the first address when the scan found it
+        // unused. If it was the active one, the new list's first takes over,
+        // and the background is told as when the user picks one on Home.
+        const activeMoved =
+            state.activeAddress === firstAddress &&
+            wallet.addresses[0].address !== firstAddress;
+        if (activeMoved) state.activeAddress = wallet.addresses[0].address;
         await saveState();
         ctx.renderWalletList();
+        if (activeMoved) notify({ type: "AUTISTMASK_ACTIVE_CHANGED" });
         showFlash("Found " + scan.addresses.length + " addresses.");
     } else {
         showFlash("Ready.", 1000);
@@ -248,6 +266,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();
@@ -299,11 +320,19 @@ async function importXprvKey(ctx) {
         encryptedSecret: encrypted,
         nextIndex: 1,
         addresses: [
-            { address: firstAddress, balance: "0.0000", tokenBalances: [] },
+            {
+                address: firstAddress,
+                index: 0,
+                balance: "0.0000",
+                tokenBalances: [],
+            },
         ],
     };
     state.wallets.push(wallet);
     state.hasWallet = true;
+    if (state.activeAddress === null) {
+        state.activeAddress = firstAddress;
+    }
     await saveState();
     clearViewStack();
     ctx.renderWalletList();
@@ -320,12 +349,20 @@ 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: [],
         }));
         wallet.nextIndex = scan.nextIndex;
+        // As for a recovery phrase: an active first address the scan left
+        // out gives way to the new list's first.
+        const activeMoved =
+            state.activeAddress === firstAddress &&
+            wallet.addresses[0].address !== firstAddress;
+        if (activeMoved) state.activeAddress = wallet.addresses[0].address;
         await saveState();
         ctx.renderWalletList();
+        if (activeMoved) notify({ type: "AUTISTMASK_ACTIVE_CHANGED" });
         showFlash("Found " + scan.addresses.length + " addresses.");
     } else {
         showFlash("Ready.", 1000);

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 report that refusal as a wrong password.
+        // take a password and then refuse.
         const defect = selectedWalletDefect();
         if (defect) {
             showFlash(defect.shortMessage);

src/popup/views/approval.js

@@ -27,7 +27,6 @@ const {
     Interface,
     MaxUint256,
     toUtf8String,
-    TypedDataEncoder,
 } = require("ethers");
 const { getPrice, formatUsd } = require("../../shared/prices");
 const { ERC20_ABI } = require("../../shared/constants");
@@ -48,6 +47,8 @@ const { getSignerForAddress } = require("../../shared/wallet");
 const { walletDefect } = require("../../shared/walletDefects");
 const {
     describeSigningFailure,
+    signedPrimaryType,
+    typedDataMessageRefusal,
     typedDataChainRefusal,
 } = require("../../shared/approvalVerify");
 const txStatus = require("./txStatus");
@@ -298,6 +299,23 @@ function showTxApproval(details) {
                 sources,
             );
         }
+        // A swap the decoder read no amount for, such as one whose V4 swap
+        // action could not be read or a V4 exact-out swap. The wait and error
+        // screens say the amount could not be decoded, with no currency after
+        // it, rather than show the transaction's ETH value as the amount. A
+        // swap paid in native ETH keeps that value: it is the ETH the swap
+        // pays (for an exact-out swap, the most it pays), not a figure that
+        // had to be read from the calldata.
+        const tokenIn = decoded.details.find((d) => d.label === "Token In");
+        if (
+            tokenIn &&
+            tokenIn.value !== "ETH (native)" &&
+            !decoded.details.some((d) => d.label === "Amount")
+        ) {
+            pendingTxDetails.amount = "Unknown (could not be decoded)";
+            pendingTxDetails.token = null;
+            pendingTxDetails.tokenSymbol = null;
+        }
     }
 
     // Carry decoded calldata info through to success/error views
@@ -432,22 +450,12 @@ 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 domain may name no chain but the active
-// network's.
+// 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.
 function typedDataRefusal(sp) {
     if (sp.method === "personal_sign" || sp.method === "eth_sign") return null;
     let data;
@@ -470,7 +478,10 @@ function typedDataRefusal(sp) {
             ", so it cannot be signed."
         );
     }
-    return typedDataChainRefusal(data.domain, currentNetwork());
+    return (
+        typedDataMessageRefusal(data.types, signed, data.message, "") ||
+        typedDataChainRefusal(data.domain, currentNetwork())
+    );
 }
 
 // The largest amount a Permit2 allowance can hold, a uint160. Permit2 treats
@@ -626,10 +637,38 @@ function permitWarningHtml(types, primaryType, domain, message) {
     return html;
 }
 
+// What ethers signs of a message value of type `type`: a struct keeps only
+// the fields its type declares, in the type's order, and a list is read item
+// by item. ethers drops every other key, so each one is added to `notSigned`
+// with its place in the message and its value, for the screen to list apart.
+function signedValue(types, type, value, path, notSigned) {
+    const itemType = type.replace(/\[\d*\]$/, "");
+    if (itemType !== type) {
+        if (!Array.isArray(value)) return value;
+        return value.map((item, i) =>
+            signedValue(types, itemType, item, `${path}[${i}]`, notSigned),
+        );
+    }
+    const fields = types[type];
+    if (!fields || !value || typeof value !== "object") return value;
+    const at = (name) => (path ? `${path}.${name}` : name);
+    for (const [key, val] of Object.entries(value)) {
+        if (!fields.some((f) => f.name === key)) notSigned.push([at(key), val]);
+    }
+    return Object.fromEntries(
+        fields.map((f) => [
+            f.name,
+            signedValue(types, f.type, value[f.name], at(f.name), notSigned),
+        ]),
+    );
+}
+
 // The typed data as the screen shows it. The primary type shown is the one
 // ethers signs, never the page's word for it; typedDataRefusal() keeps the two
-// from differing on anything that can be signed. Only typed data that cannot
-// be read at all is shown as raw text, and typedDataRefusal() refuses it.
+// from differing on anything that can be signed. The Message section shows
+// only what is signed, and any other key the page sent is listed after it as
+// not part of the signature. Only typed data that cannot be read at all is
+// shown as raw text, and typedDataRefusal() refuses it.
 function formatTypedDataHtml(jsonStr) {
     let data;
     let primaryType;
@@ -663,12 +702,30 @@ function formatTypedDataHtml(jsonStr) {
     html += `<div class="mb-2"><div class="text-muted">Primary type</div>`;
     html += `<div class="font-bold">${escapeHtml(primaryType)}</div></div>`;
 
+    const lineHtml = (key, val) =>
+        `<div><span class="text-muted">${escapeHtml(key)}:</span> <span class="break-all">${escapeHtml(display(val))}</span></div>`;
+
     if (data.message) {
+        const notSigned = [];
+        const message = signedValue(
+            data.types,
+            primaryType,
+            data.message,
+            "",
+            notSigned,
+        );
         html += `<div class="mb-2"><div class="text-muted">Message</div>`;
-        for (const [key, val] of Object.entries(data.message)) {
-            html += `<div><span class="text-muted">${escapeHtml(key)}:</span> <span class="break-all">${escapeHtml(display(val))}</span></div>`;
+        for (const [key, val] of Object.entries(message)) {
+            html += lineHtml(key, val);
         }
         html += `</div>`;
+        if (notSigned.length > 0) {
+            html += `<div class="mb-2"><div class="text-muted">Not part of the signature</div>`;
+            for (const [key, val] of notSigned) {
+                html += lineHtml(key, val);
+            }
+            html += `</div>`;
+        }
     }
 
     return html;
@@ -725,7 +782,7 @@ function showSignApproval(details) {
             "This message is plain text, not hex, so it cannot be signed.";
     }
 
-    // Display danger warning for eth_sign (raw hash signing)
+    // The warning the background attaches to an eth_sign request.
     const warningEl = $("approve-sign-danger-warning");
     if (warningEl) {
         if (sp.dangerWarning) {
@@ -867,15 +924,15 @@ function gateOnWalletDefect(errorId, buttonId, address) {
     return true;
 }
 
-// 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.
+// 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.
 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, addrIndex: i };
+                return { wallet, addr: wallet.addresses[i] };
             }
         }
     }
@@ -1002,7 +1059,7 @@ function init(_ctx) {
         try {
             const signer = getSignerForAddress(
                 active.wallet,
-                active.addrIndex,
+                active.addr,
                 decryptedSecret,
             );
             // Sign the approved transaction exactly as it was displayed. The
@@ -1130,7 +1187,7 @@ function init(_ctx) {
         try {
             const signer = getSignerForAddress(
                 active.wallet,
-                active.addrIndex,
+                active.addr,
                 decryptedSecret,
             );
             const sp = pendingSignParams;

src/popup/views/confirmTx.js

@@ -101,6 +101,10 @@ function show(txInfo) {
     feeStatus = FEE_PENDING;
     feeWei = null;
     maxSendFees = null;
+    // The network this screen is drawn for, and the only one it sends on:
+    // Settings can switch the active network while the screen is open. The
+    // wait, success and error screens label the amount by it too.
+    txInfo.chainId = currentNetwork().chainId;
 
     const isErc20 = txInfo.token !== "ETH";
     // The raw symbol is the price-table key; the capped one is what the
@@ -274,6 +278,7 @@ function renderValidation(txInfo) {
     const { canSend, codes } = validateTransfer({
         isErc20,
         amount: txInfo.amount,
+        tokenDecimals: txInfo.tokenDecimals,
         ethBalance: txInfo.balance,
         tokenBalance: txInfo.tokenBalance,
         feeStatus,
@@ -490,7 +495,12 @@ async function populateVerifyAndSend(connectedSigner, tx, fees = null) {
         );
         request = await contract.transfer.populateTransaction(tx.to, amount);
     }
-    const populated = await connectedSigner.populateTransaction(request);
+    // The chain id of the network the screen was drawn for: ethers refuses to
+    // populate it for a provider on any other network.
+    const populated = await connectedSigner.populateTransaction({
+        ...request,
+        chainId: tx.chainId,
+    });
     assertWithinCeilings(populated);
     return connectedSigner.sendTransaction(populated);
 }
@@ -547,6 +557,30 @@ function init(_ctx) {
             return;
         }
 
+        // Back from Settings only unhides this screen, still drawn for the
+        // network that was active when it was shown.
+        if (currentNetwork().chainId !== pendingTx.chainId) {
+            showSendError(
+                "The active network changed after this transaction was" +
+                    " reviewed, so it was not sent. Please go back and review" +
+                    " it again.",
+            );
+            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(
@@ -575,17 +609,9 @@ function init(_ctx) {
         $("btn-confirm-send").disabled = true;
         $("btn-confirm-send").classList.add("text-muted");
 
-        // The network it is sent on. The wait, success and error screens
-        // label its amount by this, not by the network active when they draw.
-        pendingTx.chainId = currentNetwork().chainId;
-
         let tx;
         try {
-            const signer = getSignerForAddress(
-                wallet,
-                state.selectedAddress,
-                decryptedSecret,
-            );
+            const signer = getSignerForAddress(wallet, addr, decryptedSecret);
             const provider = getProvider(state.rpcUrl, state.networkId);
             const connectedSigner = signer.connect(provider);
 

src/popup/views/exportPrivkey.js

@@ -135,7 +135,18 @@ async function reveal() {
         // decrypt ran, the wipe has already happened, so the key is not
         // even derived, let alone written.
         if (!isCurrentReveal(generation)) return;
-        const signer = getSignerForAddress(wallet, addressIndex, secret);
+        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;
+        }
         $("export-privkey-password").value = "";
         $("export-privkey-password-section").classList.add("hidden");
         $("export-privkey-value").textContent = signer.privateKey;

src/popup/views/home.js

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

src/popup/views/send.js

@@ -24,6 +24,7 @@ const {
 } = require("../../shared/amountDisplay");
 const {
     feeReserveWei,
+    isValidAmount,
     maxEthAmount,
     maxTokenAmount,
 } = require("../../shared/txValidation");
@@ -255,13 +256,18 @@ async function fillMaxAmount() {
     const token = state.selectedToken || $("send-token").value;
 
     if (token !== "ETH") {
-        const bal = tokenBalanceAndDecimals(addr, token).tokenBalance;
+        const { tokenBalance: bal, tokenDecimals } = tokenBalanceAndDecimals(
+            addr,
+            token,
+        );
         if (bal == null) {
             showFlash("This token's balance is unknown.");
             return;
         }
         const amount = maxTokenAmount(bal);
-        if (!(parseFloat(amount) > 0)) {
+        // The balance is stored at the token's own decimal places and cut to
+        // 18 above, so the only balance this refuses is zero.
+        if (!isValidAmount(amount, tokenDecimals)) {
             showFlash("This token's balance is zero.");
             return;
         }
@@ -367,7 +373,28 @@ function init(_ctx) {
             );
             return;
         }
-        if (!amount || isNaN(parseFloat(amount)) || parseFloat(amount) <= 0) {
+
+        const token = state.selectedToken || $("send-token").value;
+        const addr = currentAddress();
+
+        let tokenSymbol = null;
+        let tokenBalance = null;
+        let tokenDecimals = null;
+        if (token !== "ETH") {
+            tokenSymbol = resolveSymbol(
+                token,
+                addr.tokenBalances,
+                state.trackedTokens,
+            );
+            ({ tokenBalance, tokenDecimals } = tokenBalanceAndDecimals(
+                addr,
+                token,
+            ));
+        }
+
+        // The confirmation screen's own amount check, so it is never shown
+        // an amount it would refuse.
+        if (!isValidAmount(amount, tokenDecimals)) {
             showFlash("Please enter a valid amount.");
             return;
         }
@@ -391,24 +418,6 @@ function init(_ctx) {
             }
         }
 
-        const token = state.selectedToken || $("send-token").value;
-        const addr = currentAddress();
-
-        let tokenSymbol = null;
-        let tokenBalance = null;
-        let tokenDecimals = null;
-        if (token !== "ETH") {
-            tokenSymbol = resolveSymbol(
-                token,
-                addr.tokenBalances,
-                state.trackedTokens,
-            );
-            ({ tokenBalance, tokenDecimals } = tokenBalanceAndDecimals(
-                addr,
-                token,
-            ));
-        }
-
         ctx.showConfirmTx({
             from: addr.address,
             to: resolvedTo,

src/popup/views/settings.js

@@ -76,11 +76,13 @@ function forgetOrigin(siteMap, origin) {
 
 // Removing a site from Allowed Sites or Connected Sites disconnects it: it is
 // no longer allowed under any address, and the background ends its
-// connections approved without "Remember" and tells its open tabs.
+// connections approved without "Remember" and tells its open tabs. The
+// background answers once those have ended, so the lists drawn after it no
+// longer show the site.
 async function removeAllowedSite(origin) {
     forgetOrigin(state.allowedSites, origin);
     await saveState();
-    notify({ type: "AUTISTMASK_REMOVE_SITE", origin });
+    await sendMessage({ type: "AUTISTMASK_REMOVE_SITE", origin });
     await renderSiteLists();
 }
 
@@ -230,8 +232,8 @@ async function renderSiteLists() {
         Object.values(state.deniedSites).flat(),
         removeDeniedSite,
     );
-    // Sites allowed without "Remember" are held only by the background, in
-    // memory, so it is asked for them.
+    // Sites allowed without "Remember" are held only in session storage, which
+    // the background keeps, so it is asked for them.
     renderSiteList(
         "settings-connected-sites",
         await sendMessage({ type: "AUTISTMASK_GET_CONNECTED_SITES" }),

src/popup/views/transactionDetail.js

@@ -183,7 +183,7 @@ function render() {
         if (el) el.classList.add("hidden");
     }
 
-    loadFullTxDetails(tx.hash, tx.to, tx.chainId);
+    loadFullTxDetails(tx.hash, tx.chainId);
 
     const isoStr = isoDate(tx.timestamp);
     $("tx-detail-time").innerHTML =
@@ -291,7 +291,7 @@ function populateOnChainDetails(txData, chainId) {
     }
 }
 
-async function loadFullTxDetails(txHash, toAddress, chainId) {
+async function loadFullTxDetails(txHash, chainId) {
     const section = $("tx-detail-calldata-section");
     const actionEl = $("tx-detail-calldata-action");
     const detailsEl = $("tx-detail-calldata-details");
@@ -313,7 +313,10 @@ async function loadFullTxDetails(txHash, toAddress, chainId) {
         const inputData = txData.raw_input || txData.input || null;
         if (!inputData || inputData === "0x") return;
 
-        const decoded = decodeCalldata(inputData, toAddress || "");
+        // Decoded against the address the transaction was sent to, as the
+        // explorer reports it, not the history entry's `to`: for a token
+        // transfer that is the transfer's recipient, not the token contract.
+        const decoded = decodeCalldata(inputData, txData.to?.hash || "");
         if (decoded) {
             // Render decoded calldata matching approval view style
             actionEl.textContent = decoded.name;

src/popup/views/txStatus.js

@@ -91,12 +91,17 @@ function startWait(txInfo, txHash, broadcastTime, pollNow) {
     // native currency of txInfo.chainId, the network the transaction was sent
     // on, not the active network's: the active network can change, in
     // Settings or when the user approves a site's request, while this screen
-    // is open or before a later popup resumes it.
-    const symbol =
-        txInfo.token === "ETH"
-            ? nativeCurrencyByChainId(txInfo.chainId)
-            : displaySymbol(txInfo.tokenSymbol || "?");
-    $("wait-tx-summary").textContent = txInfo.amount + " " + symbol;
+    // is open or before a later popup resumes it. A null token is a swap whose
+    // amount was not decoded (see showTxApproval() in approval.js): the amount
+    // says so, and no symbol follows it.
+    let symbol = "";
+    if (txInfo.token === "ETH") {
+        symbol = nativeCurrencyByChainId(txInfo.chainId);
+    } else if (txInfo.token !== null) {
+        symbol = displaySymbol(txInfo.tokenSymbol || "?");
+    }
+    $("wait-tx-summary").textContent =
+        txInfo.amount + (symbol ? " " + symbol : "");
     $("wait-tx-to").innerHTML = toAddressHtml(txInfo.to);
     $("wait-tx-hash").innerHTML = txHashHtml(txHash);
     attachCopyHandlers("view-wait-tx");
@@ -231,10 +236,13 @@ function restoreWait() {
 function showSuccess(txInfo, txHash, blockNumber) {
     endWait();
 
-    const symbol =
-        txInfo.token === "ETH"
-            ? nativeCurrencyByChainId(txInfo.chainId)
-            : displaySymbol(txInfo.tokenSymbol || "?");
+    // As on the wait screen, a null token has no symbol.
+    let symbol = "";
+    if (txInfo.token === "ETH") {
+        symbol = nativeCurrencyByChainId(txInfo.chainId);
+    } else if (txInfo.token !== null) {
+        symbol = displaySymbol(txInfo.tokenSymbol || "?");
+    }
     state.viewData = {
         amount: txInfo.amount,
         symbol: symbol,
@@ -294,7 +302,8 @@ function renderSuccess() {
     } else {
         summarySection.classList.remove("hidden");
         toSection.classList.remove("hidden");
-        $("success-tx-summary").textContent = d.amount + " " + d.symbol;
+        $("success-tx-summary").textContent =
+            d.amount + (d.symbol ? " " + d.symbol : "");
         $("success-tx-to").innerHTML = toAddressHtml(d.to);
     }
 
@@ -317,10 +326,13 @@ function renderSuccess() {
 function showError(txInfo, txHash, message) {
     endWait();
 
-    const symbol =
-        txInfo.token === "ETH"
-            ? nativeCurrencyByChainId(txInfo.chainId)
-            : displaySymbol(txInfo.tokenSymbol || "?");
+    // As on the wait screen, a null token has no symbol.
+    let symbol = "";
+    if (txInfo.token === "ETH") {
+        symbol = nativeCurrencyByChainId(txInfo.chainId);
+    } else if (txInfo.token !== null) {
+        symbol = displaySymbol(txInfo.tokenSymbol || "?");
+    }
     state.viewData = {
         amount: txInfo.amount,
         symbol: symbol,
@@ -334,7 +346,8 @@ function showError(txInfo, txHash, message) {
 function renderError() {
     const d = state.viewData;
     if (!d || !d.message) return;
-    $("error-tx-summary").textContent = d.amount + " " + d.symbol;
+    $("error-tx-summary").textContent =
+        d.amount + (d.symbol ? " " + d.symbol : "");
     $("error-tx-to").innerHTML = toAddressHtml(d.to);
     $("error-tx-message").textContent = d.message;
 

src/shared/approvalTx.js

@@ -1,13 +1,14 @@
 // Preparation of the transaction an approval screen displays.
 //
-// A dApp's eth_sendTransaction normally fixes only `to`, `value` and `data`.
-// The nonce, the gas limit and the fees have to be filled in from the network
-// before anything can be signed, and whoever fills them in decides what the
-// user is shown. That work used to happen in the popup, after the user had
-// already approved: the numbers on the approval screen came from the popup and
-// were compared against nothing, so a compromised popup could display one fee
-// and sign another, and the ceilings in approvalVerify.js were all that stood
-// between the user and a fee that hands the validator the balance.
+// A dApp's eth_sendTransaction normally fixes `to`, `value` and `data`, and
+// sometimes the gas limit. The nonce, the fees, and the gas limit when the
+// site gives none have to be filled in from the network before anything can
+// be signed, and whoever fills them in decides what the user is shown. That
+// work used to happen in the popup, after the user had already approved: the
+// numbers on the approval screen came from the popup and were compared against
+// nothing, so a compromised popup could display one fee and sign another, and
+// the ceilings in approvalVerify.js were all that stood between the user and a
+// fee that hands the validator the balance.
 //
 // So it happens here instead, in the background, before the approval window is
 // opened. The background populates the transaction, shows that object, and
@@ -31,6 +32,7 @@ const {
     VoidSigner,
     accessListify,
     getAddress,
+    getBigInt,
     getBytes,
     hexlify,
     toQuantity,
@@ -39,6 +41,7 @@ const {
     ALLOWED_TX_TYPES,
     SERIALIZED_FIELDS,
     assertWithinCeilings,
+    nodeError,
 } = require("./approvalVerify");
 
 // How long the population may take before the request is failed back to the
@@ -47,10 +50,11 @@ const {
 // minutes long, which is not a wait anyone will sit through.
 const POPULATE_TIMEOUT_MS = 20000;
 
-// The request fields taken from the page. Anything else is dropped rather than
-// passed to ethers: the object is page-controlled, and a future ethers that
-// learns to carry a new transaction field must not start picking one up out of
-// it without this module knowing.
+// The request fields taken from the page, plus `gas`, which requestFrom()
+// takes as the gas limit. Anything else is dropped rather than passed to
+// ethers: the object is page-controlled, and a future ethers that learns to
+// carry a new transaction field must not start picking one up out of it
+// without this module knowing.
 //
 // The nonce is not taken from the page; it is always the account's next nonce
 // from the network. A page that chose it could replace one of the user's
@@ -69,21 +73,43 @@ const REQUEST_FIELDS = [
     "type",
 ];
 
+// EIP-1474's code for invalid parameters: what the page is given when the
+// site asked for a transaction this wallet refuses as it was asked for.
+const INVALID_PARAMS_CODE = -32602;
+
+// Why no approval can be raised. The message is the sentence the page is
+// shown. `code` and `data` are the JSON-RPC ones it is given with it: the
+// node's own, unchanged, when the node refused the transaction, so a site can
+// decode a revert; INVALID_PARAMS_CODE when the site's request is refused;
+// none when the failure is the wallet's own, which the background answers as
+// an internal error.
 class ApprovalPrepareError extends Error {
-    constructor(message) {
+    constructor(message, code, data) {
         super(message);
         this.name = "ApprovalPrepareError";
+        if (code !== undefined) this.code = code;
+        if (data !== undefined) this.data = data;
     }
 }
 
-function fail(message) {
-    return new ApprovalPrepareError(message);
+function fail(message, code, data) {
+    return new ApprovalPrepareError(message, code, data);
 }
 
 function present(v) {
     return v !== null && v !== undefined && v !== "";
 }
 
+// Whether two quantities from the page are the same number. One that is not a
+// number matches nothing.
+function sameQuantity(a, b) {
+    try {
+        return getBigInt(a) === getBigInt(b);
+    } catch {
+        return false;
+    }
+}
+
 // These strings reach the user through the requesting page, so they are full
 // sentences even when the tail of one came from ethers or from the node.
 function sentence(text) {
@@ -111,12 +137,28 @@ function requestFrom(txParams, from) {
     for (const key of REQUEST_FIELDS) {
         if (present(txParams[key])) request[key] = txParams[key];
     }
+    // JSON-RPC calls the gas limit `gas`, and that is the name sites send.
+    // ethers only reads `gasLimit`: left as `gas` it would be dropped and an
+    // estimate signed in its place.
+    if (present(txParams.gas)) {
+        if (
+            present(request.gasLimit) &&
+            !sameQuantity(request.gasLimit, txParams.gas)
+        ) {
+            throw fail(
+                "The site asked for two different gas limits for this transaction.",
+                INVALID_PARAMS_CODE,
+            );
+        }
+        request.gasLimit = txParams.gas;
+    }
     if (
         present(request.type) &&
         !ALLOWED_TX_TYPES.includes(Number(request.type))
     ) {
         throw fail(
             "The site asked for a transaction of a type this wallet does not sign.",
+            INVALID_PARAMS_CODE,
         );
     }
     return request;
@@ -174,6 +216,7 @@ async function prepareApprovalTx(provider, from, txParams) {
         throw fail("There is no active address to send this transaction from.");
     }
     const request = requestFrom(txParams || {}, from);
+    const signer = new VoidSigner(getAddress(from), provider);
 
     let populated;
     try {
@@ -181,15 +224,28 @@ async function prepareApprovalTx(provider, from, txParams) {
         // nonce, gas, fee and chain id are populated exactly as they were when
         // the popup did this. VoidSigner cannot sign, which is the point: the
         // background prepares, the popup signs.
+        //
+        // ethers asks the node for a gas estimate only when the request has
+        // no gas limit, and that estimate is the only check that the
+        // transaction does not revert. So a request carrying the site's gas
+        // limit is estimated first, with that limit: one that reverts, or
+        // needs more gas than the site gave it, fails here as well. The
+        // site's gas limit is still the one populated.
         populated = await withTimeout(
-            new VoidSigner(getAddress(from), provider).populateTransaction(
-                request,
-            ),
+            (async () => {
+                if (present(request.gasLimit)) {
+                    await signer.estimateGas(request);
+                }
+                return signer.populateTransaction(request);
+            })(),
             POPULATE_TIMEOUT_MS,
             "The transaction could not be prepared: the network did not answer in time.",
         );
     } catch (e) {
         if (e instanceof ApprovalPrepareError) throw e;
+        // A refusal from the node, such as a reverting gas estimate, keeps
+        // the node's code and revert data.
+        const fromNode = nodeError(e);
         throw fail(
             sentence(
                 "The transaction could not be prepared: " +
@@ -197,6 +253,8 @@ async function prepareApprovalTx(provider, from, txParams) {
                         e.message ||
                         "the network did not answer"),
             ),
+            fromNode?.code,
+            fromNode?.data,
         );
     }
 

src/shared/approvalVerify.js

@@ -56,6 +56,7 @@ const {
     getBigInt,
     getBytes,
     toQuantity,
+    TypedDataEncoder,
     verifyMessage,
     verifyTypedData,
 } = require("ethers");
@@ -636,6 +637,63 @@ 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.
@@ -688,6 +746,15 @@ function errorText(err) {
     return "The transaction could not be sent.";
 }
 
+// The JSON-RPC error object the node answered with, `{ code, message, data }`,
+// out of the error ethers threw for that answer. ethers keeps it under
+// `info.error`, or under `error` when it could not classify it. Null when
+// there is none, as for a node that could not be reached.
+function nodeError(err) {
+    if (!err || typeof err !== "object") return null;
+    return err.error || (err.info && err.info.error) || null;
+}
+
 // Every string a failure might carry its reason in. ethers reports the node's
 // own words in `shortMessage`, but a JSON-RPC error it could not classify is
 // nested under `error` or `info.error` with the node's message intact, and the
@@ -699,7 +766,7 @@ function failureTexts(err) {
     for (const text of [err.shortMessage, err.message, err.reason]) {
         if (text) texts.push(String(text));
     }
-    const nested = err.error || (err.info && err.info.error);
+    const nested = nodeError(err);
     if (nested && nested.message) texts.push(String(nested.message));
     return texts;
 }
@@ -824,6 +891,8 @@ function describeSigningFailure(response, fallbackMessage) {
 module.exports = {
     verifySignedTx,
     verifySignature,
+    signedPrimaryType,
+    typedDataMessageRefusal,
     typedDataChainRefusal,
     assertNoForbiddenFields,
     assertNothingUnchecked,
@@ -831,6 +900,7 @@ module.exports = {
     assertWithinCeilings,
     sameAddress,
     failureIsRetryable,
+    nodeError,
     isNonceCollision,
     describeTxFailure,
     describeSigningFailure,

src/shared/browserApi.js

@@ -145,6 +145,14 @@ function sendMessage(message) {
     return invoke(runtimeApi(), "sendMessage", message);
 }
 
+/**
+ * @returns {Promise<Object>} the operating system and processor the browser
+ *     runs on.
+ */
+function getPlatformInfo() {
+    return invoke(runtimeApi(), "getPlatformInfo");
+}
+
 /**
  * Send a message nobody is expected to answer, and swallow the fact that
  * nobody did.
@@ -166,9 +174,9 @@ function notify(message) {
 // default: resolving {} would make an existing wallet read back as no wallet,
 // and resolving a no-op write would discard the user's state with nothing
 // logged. A caller that wants to degrade takes storageLocal() directly.
-function storageUnavailable(method) {
+function storageUnavailable(area, method) {
     return Promise.reject(
-        new Error("extension storage.local is not available: " + method),
+        new Error("extension storage." + area + " is not available: " + method),
     );
 }
 
@@ -179,7 +187,7 @@ function storageUnavailable(method) {
  */
 function storageGet(keys) {
     const storage = storageLocal();
-    if (!storage) return storageUnavailable("get");
+    if (!storage) return storageUnavailable("local", "get");
     return Promise.resolve(storage.get(keys));
 }
 
@@ -190,7 +198,7 @@ function storageGet(keys) {
  */
 function storageSet(items) {
     const storage = storageLocal();
-    if (!storage) return storageUnavailable("set");
+    if (!storage) return storageUnavailable("local", "set");
     return Promise.resolve(storage.set(items));
 }
 
@@ -207,7 +215,55 @@ function storageSet(items) {
  */
 function storageRemove(keys) {
     const storage = storageLocal();
-    if (!storage) return storageUnavailable("remove");
+    if (!storage) return storageUnavailable("local", "remove");
+    return Promise.resolve(storage.remove(keys));
+}
+
+// `storage.session`, the browser's session storage: what is kept there lasts
+// until the browser closes. It survives the background worker being stopped
+// and started again, which module-level variables do not (README, Background
+// scheduling). The background keeps the connections allowed without
+// "Remember" there; see src/background/index.js. Firefox has it from version
+// 115, the minimum manifest/firefox.json declares.
+//
+// The three below reject where it is absent, as the three above do where
+// `storage.local` is: a write that silently did nothing would tell a site it
+// is connected and then refuse its next request.
+function storageSession() {
+    const storage = namespaceMember("storage");
+    return (storage && storage.session) || null;
+}
+
+/**
+ * @param {string|string[]|null} keys null for every item.
+ * @returns {Promise<Object>} the stored items.
+ * @throws rejects where `storage.session` is absent.
+ */
+function sessionStorageGet(keys) {
+    const storage = storageSession();
+    if (!storage) return storageUnavailable("session", "get");
+    return Promise.resolve(storage.get(keys));
+}
+
+/**
+ * @param {Object} items
+ * @returns {Promise<void>}
+ * @throws rejects where `storage.session` is absent.
+ */
+function sessionStorageSet(items) {
+    const storage = storageSession();
+    if (!storage) return storageUnavailable("session", "set");
+    return Promise.resolve(storage.set(items));
+}
+
+/**
+ * @param {string|string[]} keys
+ * @returns {Promise<void>}
+ * @throws rejects where `storage.session` is absent.
+ */
+function sessionStorageRemove(keys) {
+    const storage = storageSession();
+    if (!storage) return storageUnavailable("session", "remove");
     return Promise.resolve(storage.remove(keys));
 }
 
@@ -235,6 +291,22 @@ function tabsSendMessage(tabId, message) {
     return invoke(tabsApi(), "sendMessage", tabId, message);
 }
 
+/**
+ * @returns {Promise<Object|undefined>} the tab the calling page is in, or
+ *     undefined for a page not in a tab, such as the toolbar popup.
+ */
+function tabsGetCurrent() {
+    return invoke(tabsApi(), "getCurrent");
+}
+
+/**
+ * @param {number} tabId
+ * @returns {Promise<number>} that tab's zoom: 1.5 at 150%.
+ */
+function tabsGetZoom(tabId) {
+    return invoke(tabsApi(), "getZoom", tabId);
+}
+
 /**
  * @param {Object} createData
  * @returns {Promise<Object>} the created window.
@@ -250,6 +322,22 @@ function windowsGetLastFocused() {
     return invoke(windowsApi(), "getLastFocused");
 }
 
+/**
+ * @returns {Promise<Object>} the window the calling page is in.
+ */
+function windowsGetCurrent() {
+    return invoke(windowsApi(), "getCurrent");
+}
+
+/**
+ * @param {number} windowId
+ * @param {Object} updateInfo
+ * @returns {Promise<Object>} the updated window.
+ */
+function windowsUpdate(windowId, updateInfo) {
+    return invoke(windowsApi(), "update", windowId, updateInfo);
+}
+
 /**
  * @param {number} windowId
  * @returns {Promise<void>}
@@ -262,19 +350,27 @@ module.exports = {
     actionApi,
     alarmsApi,
     extensionApi,
+    getPlatformInfo,
     hasBrowserNamespace,
     notify,
     runtimeApi,
     sendMessage,
+    sessionStorageGet,
+    sessionStorageRemove,
+    sessionStorageSet,
     storageGet,
     storageLocal,
     storageRemove,
     storageSet,
     tabsApi,
+    tabsGetCurrent,
+    tabsGetZoom,
     tabsQuery,
     tabsSendMessage,
     windowsApi,
     windowsCreate,
+    windowsGetCurrent,
     windowsGetLastFocused,
     windowsRemove,
+    windowsUpdate,
 };

src/shared/tokenList.js

@@ -576,7 +576,7 @@ const TOKENS = [
         symbol: "FLOKI",
         decimals: 9,
         name: "FLOKI",
-        url: "",
+        url: "https://floki.com",
     },
     {
         address: "0x7420B4b9a0110cdC71fB720908340C03F9Bc03EC",
@@ -1290,7 +1290,7 @@ const TOKENS = [
         symbol: "TURBO",
         decimals: 18,
         name: "Turbo",
-        url: "",
+        url: "https://www.turbo-eth.com",
     },
     {
         address: "0xA27EC0006e59f245217Ff08CD52A7E8b169E62D2",

src/shared/txValidation.js

@@ -1,4 +1,5 @@
-// Balance arithmetic for the Send and transaction confirmation screens.
+// The amount check and balance arithmetic for the Send and transaction
+// confirmation screens.
 //
 // Pure: no DOM, no network, no state. Everything is exact integer math on
 // 18-decimal fixed point (wei for ETH), so it can be unit tested directly
@@ -20,7 +21,7 @@ const FEE_KNOWN = "known";
 const FEE_UNAVAILABLE = "unavailable";
 
 const CODES = {
-    // The amount is not a non-negative number we can do exact arithmetic on.
+    // The amount is one isValidAmount() refuses.
     AMOUNT_INVALID: "amount-invalid",
     // ERC-20: the token amount exceeds the token balance.
     INSUFFICIENT_TOKEN: "insufficient-token",
@@ -87,6 +88,27 @@ function toFixedPoint(value) {
     }
 }
 
+// Whether `amount` can be sent: a number above zero, written as digits with
+// at most one decimal point ("0.5", "12", ".5"), with nothing but zeros after
+// the token's last decimal place, `tokenDecimals`, and nothing but zeros after
+// the 18th, the places the arithmetic here works in, which are ETH's. ETH, and
+// a token whose decimal places are unknown, pass null and are held to the 18
+// (the confirmation screen refuses to send such a token anyway). Zeros past
+// those places are accepted because parseUnits() drops them here and again
+// when the transfer is encoded, so "1.0000000" of a 6-place token is exactly
+// 1 everywhere. Refuses "1e-3", "1abc", "0" and "-1". The Send screen checks
+// it before the confirmation screen opens, and validateTransfer() checks it
+// again there.
+function isValidAmount(amount, tokenDecimals = null) {
+    if (typeof amount !== "string") return false;
+    const places = Math.min(tokenDecimals ?? SCALE_DECIMALS, SCALE_DECIMALS);
+    try {
+        return parseUnits(amount.trim(), places) > 0n;
+    } catch {
+        return false;
+    }
+}
+
 // The most ETH a send can carry: the exact balance minus the fee reserve from
 // feeReserveWei(), as a decimal string, so validateTransfer() passes it with
 // exactly that reserve left behind. `ethBalance` is the exact decimal string
@@ -112,9 +134,11 @@ function maxTokenAmount(tokenBalance) {
 // Validate a pending transfer against the balances that must cover it.
 //
 //   isErc20      — token transfer rather than a native ETH transfer
-//   amount       — human decimal string being sent, non-negative. Anything
-//                  else, a negative value included, is an unusable amount
+//   amount       — human decimal string being sent. One isValidAmount()
+//                  refuses, a negative value included, is an unusable amount
 //                  rather than an amount that passes every comparison.
+//   tokenDecimals — ERC-20: the token's decimal places, or null when they
+//                  are unknown. Passed to isValidAmount().
 //   ethBalance   — human decimal string, the sender's ETH balance
 //   tokenBalance — human decimal string, the sender's token balance
 //   feeStatus    — FEE_PENDING, FEE_KNOWN or FEE_UNAVAILABLE. Anything else
@@ -128,6 +152,7 @@ function maxTokenAmount(tokenBalance) {
 function validateTransfer({
     isErc20 = false,
     amount,
+    tokenDecimals = null,
     ethBalance,
     tokenBalance,
     feeStatus = FEE_PENDING,
@@ -135,17 +160,17 @@ function validateTransfer({
 } = {}) {
     const codes = [];
 
-    const amountFp = toFixedPoint(amount);
-    const ethFp = toFixedPoint(ethBalance) ?? 0n;
-
-    // A negative amount parses to a valid bigint, so every comparison below
-    // is trivially false and the send clears the screen — then dies at encode
-    // time in parseEther(). Unusable, on the same footing as a malformed fee.
-    if (amountFp === null || amountFp < 0n) {
+    // An amount refused here never reaches the comparisons below: a negative
+    // one would pass every one of them, then die at encode time in
+    // parseEther().
+    if (!isValidAmount(amount, isErc20 ? tokenDecimals : null)) {
         codes.push(CODES.AMOUNT_INVALID);
         return { canSend: false, codes };
     }
 
+    const amountFp = toFixedPoint(amount);
+    const ethFp = toFixedPoint(ethBalance) ?? 0n;
+
     // Fail closed. Anything that is not a usable fee under a recognised
     // status — a malformed feeWei, or a status this module does not know —
     // is an unavailable estimate, never a fee of zero. Every such input errs
@@ -195,6 +220,7 @@ module.exports = {
     SCALE_DECIMALS,
     feeReserveWei,
     feeEstimateWei,
+    isValidAmount,
     maxEthAmount,
     maxTokenAmount,
     toFixedPoint,

src/shared/uniswap.js

@@ -53,6 +53,11 @@ function formatAmount(raw, decimals) {
 // on a scale — not as a token name, and not as a quantity.
 const UNNAMED_CURRENCY = "Unknown (not named in the calldata)";
 
+// The same refusal when a V4 swap action could not be read (see
+// decodeExactly()). That action names both of its currencies, so saying the
+// calldata did not name one would be false.
+const UNDECODED_CURRENCY = "Unknown (could not be decoded)";
+
 // Explicit presence, never truthiness. Every gate in this file that guards a
 // decoded value goes through here: an address is never falsy once set, but an
 // amount of 0n is, and a gate that cannot tell a genuine zero from an absent
@@ -285,7 +290,9 @@ const V4_SWAP_EXACT_IN = 0x07;
 const V4_SWAP_EXACT_OUT_SINGLE = 0x08;
 const V4_SWAP_EXACT_OUT = 0x09;
 const V4_SETTLE = 0x0b;
+const V4_SETTLE_ALL = 0x0c;
 const V4_TAKE = 0x0e;
+const V4_TAKE_ALL = 0x0f;
 
 // A V4 exact-in `amountIn`, read the way V4Router reads it: zero is
 // ActionConstants.OPEN_DELTA, not a quantity of zero. See the OPEN_DELTA
@@ -295,10 +302,150 @@ function v4ExactInAmount(raw) {
     return raw === 0n ? OPEN_DELTA : raw;
 }
 
+// The V4 swap actions are read only in the parameter structs V4Router has
+// deployed on mainnet and Sepolia. v4-periphery `main` has since added a
+// `minHopPriceX36` field to all four (`src/interfaces/IV4Router.sol`), and
+// reading a shape nobody has deployed would be guessing. ethers alone would
+// read the newer structs anyway: it takes whatever word sits where a
+// deployed field would be, ignores bytes left over, and holds back an error
+// in a field until that field is used. The newer multi-hop exact-in struct
+// then yields the offset of its hop-price array as `amountIn`. So a decode
+// counts only when encoding the result again gives back the same bytes;
+// otherwise this throws, and decodeV4Swap() marks the step as not decoded.
+function decodeExactly(types, data) {
+    const decoded = coder.decode(types, data);
+    if (coder.encode(types, decoded) !== data) {
+        throw new Error("Not in the deployed V4 parameter shape.");
+    }
+    return decoded;
+}
+
+// Decode one V4 swap action's parameters into the currency it spends
+// (`tokenIn`), the currency it buys (`tokenOut`) and, for an exact-in action,
+// its `amountIn` and `amountOutMin`. The exact-out actions decode no amounts.
+// A field the action does not state is null. Throws when the parameters are
+// not in the deployed shape (see decodeExactly()).
+function decodeV4SwapAction(actionId, param) {
+    if (actionId === V4_SWAP_EXACT_IN) {
+        // ExactInputParams: (address currencyIn,
+        //   tuple(address,uint24,int24,address,bytes)[] path,
+        //   uint128 amountIn, uint128 amountOutMin)
+        const s = decodeExactly(
+            [
+                "tuple(address,tuple(address,uint24,int24,address,bytes)[],uint128,uint128)",
+            ],
+            param,
+        );
+        const path = s[0][1];
+        return {
+            tokenIn: s[0][0],
+            tokenOut: path.length > 0 ? path[path.length - 1][0] : null,
+            amountIn: v4ExactInAmount(s[0][2]),
+            amountOutMin: s[0][3],
+        };
+    }
+    if (actionId === V4_SWAP_EXACT_IN_SINGLE) {
+        // ExactInputSingleParams: (tuple(address,address,uint24,int24,address) poolKey,
+        //   bool zeroForOne, uint128 amountIn, uint128 amountOutMin, bytes hookData)
+        const s = decodeExactly(
+            [
+                "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
+            ],
+            param,
+        );
+        const poolKey = s[0][0];
+        const zeroForOne = s[0][1];
+        return {
+            tokenIn: zeroForOne ? poolKey[0] : poolKey[1],
+            tokenOut: zeroForOne ? poolKey[1] : poolKey[0],
+            amountIn: v4ExactInAmount(s[0][2]),
+            amountOutMin: s[0][3],
+        };
+    }
+    if (actionId === V4_SWAP_EXACT_OUT) {
+        // ExactOutputParams: (address currencyOut,
+        //   tuple(address,uint24,int24,address,bytes)[] path,
+        //   uint128 amountOut, uint128 amountInMaximum)
+        const s = decodeExactly(
+            [
+                "tuple(address,tuple(address,uint24,int24,address,bytes)[],uint128,uint128)",
+            ],
+            param,
+        );
+        // The router works through the path from its last entry back to its
+        // first, starting from currencyOut, so the first entry is what the
+        // action spends.
+        const path = s[0][1];
+        return {
+            tokenIn: path.length > 0 ? path[0][0] : null,
+            tokenOut: s[0][0],
+            amountIn: null,
+            amountOutMin: null,
+        };
+    }
+    // V4_SWAP_EXACT_OUT_SINGLE. ExactOutputSingleParams: (poolKey as above,
+    //   bool zeroForOne, uint128 amountOut, uint128 amountInMaximum,
+    //   bytes hookData)
+    const s = decodeExactly(
+        [
+            "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
+        ],
+        param,
+    );
+    const poolKey = s[0][0];
+    const zeroForOne = s[0][1];
+    return {
+        tokenIn: zeroForOne ? poolKey[0] : poolKey[1],
+        tokenOut: zeroForOne ? poolKey[1] : poolKey[0],
+        amountIn: null,
+        amountOutMin: null,
+    };
+}
+
+// The currencies in `list` that `other` does not hold, each listed once.
+function currenciesNotIn(list, other) {
+    return [...new Set(list.filter((c) => !other.includes(c)))];
+}
+
+// The amount that the swap actions on one side of a V4 step state together:
+// the one action's own amount, or the sum when there are several and each
+// states a quantity. Exact-out actions state none here, and the open delta is
+// not a quantity. Otherwise null.
+function totalAmount(amounts) {
+    if (amounts.length === 1) return amounts[0];
+    if (amounts.length === 0) return null;
+    if (!amounts.every((a) => typeof a === "bigint")) return null;
+    return amounts.reduce((sum, a) => sum + a, 0n);
+}
+
 // Decode V4_SWAP (command 0x10) input bytes.
-// The input is ABI-encoded as (bytes actions, bytes[] params).
-// We extract token addresses from SETTLE (input) and TAKE (output) sub-actions,
-// and swap amounts from the swap sub-actions.
+// The input is ABI-encoded as (bytes actions, bytes[] params). Each swap
+// action gives the currency it spends and the currency it buys (see
+// decodeV4SwapAction()). The step's sides then follow three rules:
+//
+// 1. Token In is the currency SETTLE or SETTLE_ALL names; otherwise the one
+//    currency that some swap action spends and none buys. Token Out is the
+//    currency TAKE or TAKE_ALL names; otherwise the one currency that some
+//    swap action buys and none spends. If there is not exactly one such
+//    currency, that side is unknown.
+// 2. Amount is the amountIn of the swap action that spends Token In. If
+//    several exact-in actions spend it, each with a stated amount, it is
+//    their sum; in any other case there is none. Min. received is the same
+//    for amountOutMin and the actions that buy Token Out.
+// 3. If any swap action in the step cannot be read, only SETTLE, SETTLE_ALL,
+//    TAKE and TAKE_ALL name the sides, and there is no Amount or Min.
+//    received.
+//
+// A currency a swap action does not name, such as what an exact-in action
+// with an empty path buys, is null and counts in rules 1 and 2 as a currency
+// like any other: a step of only that action has an unknown Token Out and
+// the action's amountOutMin as Min. received.
+//
+// `hasSwapAction` is true when the step has a swap action, read or not.
+// decode() then sets both sides from this step, a side these rules leave
+// unknown included, so no other step's token or figure shows for it. A step
+// with no swap action sets only the sides SETTLE, SETTLE_ALL, TAKE and
+// TAKE_ALL name.
 function decodeV4Swap(input) {
     try {
         const d = coder.decode(["bytes", "bytes[]"], input);
@@ -307,8 +454,13 @@ function decodeV4Swap(input) {
 
         let settleToken = null;
         let takeToken = null;
-        let amountIn = null;
-        let amountOutMin = null;
+        // The step's swap actions that could be read, as decodeV4SwapAction()
+        // reads them.
+        const swaps = [];
+        // Set when a swap action's parameters are not in the deployed shape
+        // (see decodeExactly()), so nothing was read from that action. SETTLE,
+        // SETTLE_ALL, TAKE and TAKE_ALL may still name both currencies.
+        let swapUndecoded = false;
 
         for (let i = 0; i < actions.length; i++) {
             const actionId = actions[i];
@@ -320,6 +472,10 @@ function decodeV4Swap(input) {
                         params[i],
                     );
                     settleToken = s[0];
+                } else if (actionId === V4_SETTLE_ALL) {
+                    // SETTLE_ALL: (address currency, uint256 maxAmount)
+                    const s = coder.decode(["address", "uint256"], params[i]);
+                    settleToken = s[0];
                 } else if (actionId === V4_TAKE) {
                     // TAKE: (address currency, address recipient, uint256 amount)
                     const t = coder.decode(
@@ -327,107 +483,20 @@ function decodeV4Swap(input) {
                         params[i],
                     );
                     takeToken = t[0];
+                } else if (actionId === V4_TAKE_ALL) {
+                    // TAKE_ALL: (address currency, uint256 minAmount)
+                    const t = coder.decode(["address", "uint256"], params[i]);
+                    takeToken = t[0];
                 } else if (
+                    actionId === V4_SWAP_EXACT_IN_SINGLE ||
                     actionId === V4_SWAP_EXACT_IN ||
-                    actionId === V4_SWAP_EXACT_IN_SINGLE
+                    actionId === V4_SWAP_EXACT_OUT_SINGLE ||
+                    actionId === V4_SWAP_EXACT_OUT
                 ) {
-                    // Extract amounts from exact-in swap actions
-                    if (actionId === V4_SWAP_EXACT_IN) {
-                        // ExactInputParams: (address currencyIn,
-                        //   tuple(address,uint24,int24,address,bytes)[] path,
-                        //   uint128 amountIn, uint128 amountOutMin)
-                        try {
-                            const s = coder.decode(
-                                [
-                                    "tuple(address,tuple(address,uint24,int24,address,bytes)[],uint128,uint128)",
-                                ],
-                                params[i],
-                            );
-                            if (!present(settleToken)) settleToken = s[0][0];
-                            const path = s[0][1];
-                            if (path.length > 0 && !present(takeToken)) {
-                                takeToken = path[path.length - 1][0];
-                            }
-                            if (!present(amountIn)) {
-                                amountIn = v4ExactInAmount(s[0][2]);
-                            }
-                            if (!present(amountOutMin)) {
-                                amountOutMin = s[0][3];
-                            }
-                        } catch {
-                            // Fall through — SETTLE/TAKE will provide tokens
-                        }
-                    } else {
-                        // ExactInputSingleParams: (tuple(address,address,uint24,int24,address) poolKey,
-                        //   bool zeroForOne, uint128 amountIn, uint128 amountOutMin, bytes hookData)
-                        try {
-                            const s = coder.decode(
-                                [
-                                    "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
-                                ],
-                                params[i],
-                            );
-                            const poolKey = s[0][0];
-                            const zeroForOne = s[0][1];
-                            if (!present(settleToken))
-                                settleToken = zeroForOne
-                                    ? poolKey[0]
-                                    : poolKey[1];
-                            if (!present(takeToken))
-                                takeToken = zeroForOne
-                                    ? poolKey[1]
-                                    : poolKey[0];
-                            if (!present(amountIn)) {
-                                amountIn = v4ExactInAmount(s[0][2]);
-                            }
-                            if (!present(amountOutMin)) {
-                                amountOutMin = s[0][3];
-                            }
-                        } catch {
-                            // Fall through
-                        }
-                    }
-                } else if (
-                    actionId === V4_SWAP_EXACT_OUT ||
-                    actionId === V4_SWAP_EXACT_OUT_SINGLE
-                ) {
-                    if (actionId === V4_SWAP_EXACT_OUT) {
-                        try {
-                            const s = coder.decode(
-                                [
-                                    "tuple(address,tuple(address,uint24,int24,address,bytes)[],uint128,uint128)",
-                                ],
-                                params[i],
-                            );
-                            if (!present(takeToken)) takeToken = s[0][0];
-                            const path = s[0][1];
-                            if (path.length > 0 && !present(settleToken)) {
-                                settleToken = path[path.length - 1][0];
-                            }
-                        } catch {
-                            // Fall through
-                        }
-                    } else {
-                        try {
-                            const s = coder.decode(
-                                [
-                                    "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
-                                ],
-                                params[i],
-                            );
-                            const poolKey = s[0][0];
-                            const zeroForOne = s[0][1];
-                            if (!present(settleToken))
-                                settleToken = zeroForOne
-                                    ? poolKey[0]
-                                    : poolKey[1];
-                            if (!present(takeToken))
-                                takeToken = zeroForOne
-                                    ? poolKey[1]
-                                    : poolKey[0];
-                        } catch {
-                            // Fall through
-                        }
+                    try {
+                        swaps.push(decodeV4SwapAction(actionId, params[i]));
+                    } catch {
+                        swapUndecoded = true;
                     }
                 }
             } catch {
@@ -435,11 +504,54 @@ function decodeV4Swap(input) {
             }
         }
 
+        // Rule 3.
+        if (swapUndecoded) {
+            return {
+                tokenIn: settleToken,
+                tokenOut: takeToken,
+                amountIn: null,
+                amountOutMin: null,
+                swapUndecoded,
+                hasSwapAction: true,
+            };
+        }
+
+        const spent = swaps.map((s) => s.tokenIn);
+        const bought = swaps.map((s) => s.tokenOut);
+
+        // Rules 1 and 2 for Token In.
+        let tokenIn = null;
+        let amountIn = null;
+        const spentOnly = currenciesNotIn(spent, bought);
+        if (present(settleToken) || spentOnly.length === 1) {
+            tokenIn = present(settleToken) ? settleToken : spentOnly[0];
+            amountIn = totalAmount(
+                swaps
+                    .filter((s) => s.tokenIn === tokenIn)
+                    .map((s) => s.amountIn),
+            );
+        }
+
+        // Rules 1 and 2 for Token Out.
+        let tokenOut = null;
+        let amountOutMin = null;
+        const boughtOnly = currenciesNotIn(bought, spent);
+        if (present(takeToken) || boughtOnly.length === 1) {
+            tokenOut = present(takeToken) ? takeToken : boughtOnly[0];
+            amountOutMin = totalAmount(
+                swaps
+                    .filter((s) => s.tokenOut === tokenOut)
+                    .map((s) => s.amountOutMin),
+            );
+        }
+
         return {
-            tokenIn: settleToken,
-            tokenOut: takeToken,
+            tokenIn,
+            tokenOut,
             amountIn,
             amountOutMin,
+            swapUndecoded,
+            hasSwapAction: swaps.length > 0,
         };
     } catch {
         return null;
@@ -463,8 +575,10 @@ function decode(data, toAddress, sources) {
         let inputEstablished = false;
         let outputToken = null;
         let minOutput = null;
+        let outputEstablished = false;
         let hasUnwrapWeth = false;
         let hasV2ExactOut = false;
+        let swapUndecoded = false;
         const commandNames = [];
 
         // THE INVARIANT: an amount and the token it is counted in always come
@@ -497,6 +611,7 @@ function decode(data, toAddress, sources) {
             if (!present(token) && !present(amount)) return;
             outputToken = present(token) ? token : null;
             minOutput = present(amount) ? amount : null;
+            outputEstablished = true;
         };
 
         for (let i = 0; i < commandsBytes.length; i++) {
@@ -567,18 +682,34 @@ function decode(data, toAddress, sources) {
 
                 if (cmdId === 0x10) {
                     const v4 = decodeV4Swap(inputs[i]);
-                    if (v4) {
+                    if (v4 && v4.swapUndecoded) {
+                        // A swap action of this step went unread, so the step
+                        // is marked.
+                        swapUndecoded = true;
+                        commandNames[i] += " (could not be decoded)";
+                    }
+                    if (v4 && v4.hasSwapAction) {
+                        // A step with a swap action sets both sides as a swap
+                        // step does, the input when no earlier step set it and
+                        // the output always, as the last swap step wins. Each
+                        // side is set as a pair, so a side decodeV4Swap() left
+                        // unknown is set unknown with no figure, rather than
+                        // left to another step's token and figure. A token
+                        // stated without a figure, or a figure without a
+                        // token, likewise never sits beside an earlier step's
+                        // other half.
+                        if (!inputEstablished) {
+                            setInput(v4.tokenIn, v4.amountIn);
+                        }
+                        outputToken = v4.tokenOut;
+                        minOutput = v4.amountOutMin;
+                        outputEstablished = true;
+                    } else if (v4) {
+                        // A step with no swap action sets only the sides its
+                        // SETTLE, SETTLE_ALL, TAKE or TAKE_ALL names:
+                        // setInputOnce() and setOutput() leave alone a side
+                        // whose two halves are both unstated.
                         setInputOnce(v4.tokenIn, v4.amountIn);
-                        // Always update output: last swap step wins. A step
-                        // that carries the Min. received figure but decoded no
-                        // output currency makes the output *undetermined* — it
-                        // is neither ETH nor whatever an earlier step named,
-                        // and that figure is no longer counted in that token.
-                        // Equally, a step that names an output currency but no
-                        // minimum leaves Min. received unstated rather than
-                        // keeping an earlier step's figure beside the new
-                        // token. setOutput() is both rules; a step that states
-                        // neither half leaves the output alone.
                         setOutput(v4.tokenOut, v4.amountOutMin);
                     }
                 }
@@ -591,19 +722,20 @@ function decode(data, toAddress, sources) {
             }
         }
 
-        // Resolve token info. A null token on either side means the calldata
-        // named no currency for it; tokenInfo() refuses rather than calling it
-        // ETH. UNWRAP_WETH turns WETH into ETH, so it makes the output ETH
-        // when the output side is WETH, or when no step set the output side.
-        // Any other output keeps its own token and figure: a swap that buys
-        // USDC and then unwraps the WETH it did not spend receives USDC.
+        // Resolve token info. A null token on either side means no step named
+        // a currency for it, or a V4 step with a swap action left it
+        // unknown; tokenInfo() refuses rather than calling it ETH.
+        // UNWRAP_WETH turns WETH into ETH, so it makes the output ETH when the
+        // output side is WETH, or when no step set the output side. A V4 step
+        // with a swap action did set it, even when it set it unknown. Any other
+        // output keeps its own token and figure: a swap that buys USDC and
+        // then unwraps the WETH it did not spend receives USDC.
         const outputIsWeth =
             present(outputToken) &&
             WETH_ADDRESSES.includes(outputToken.toLowerCase());
-        const outputUnset = !present(outputToken) && !present(minOutput);
         const inInfo = tokenInfo(inputToken, sources);
         const outInfo =
-            hasUnwrapWeth && (outputIsWeth || outputUnset)
+            hasUnwrapWeth && (outputIsWeth || !outputEstablished)
                 ? { symbol: "ETH", decimals: 18, address: null }
                 : tokenInfo(outputToken, sources);
 
@@ -640,7 +772,10 @@ function decode(data, toAddress, sources) {
             // rather than going missing or naming a token by default. Same
             // wording as the Token Out refusal below: the two sides of this
             // screen must not describe the same condition in two ways.
-            details.push({ label: "Token In", value: UNNAMED_CURRENCY });
+            details.push({
+                label: "Token In",
+                value: swapUndecoded ? UNDECODED_CURRENCY : UNNAMED_CURRENCY,
+            });
         }
 
         if (present(inputAmount)) {
@@ -703,7 +838,10 @@ function decode(data, toAddress, sources) {
             // rather than going missing or naming a token by default, and a
             // Min. received figure below it is never attached to a token the
             // calldata did not state.
-            details.push({ label: "Token Out", value: UNNAMED_CURRENCY });
+            details.push({
+                label: "Token Out",
+                value: swapUndecoded ? UNDECODED_CURRENCY : UNNAMED_CURRENCY,
+            });
         }
 
         if (present(minOutput)) {

src/shared/wallet.js

@@ -110,16 +110,33 @@ function addressFromPrivateKey(key) {
     return w.address;
 }
 
-function getSignerForAddress(walletData, addrIndex, decryptedSecret) {
+// 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;
     if (walletData.type === "hd") {
         const node = HDNodeWallet.fromPhrase(
             decryptedSecret,
             "",
             BIP44_ETH_PATH,
         );
-        return node.deriveChild(addrIndex);
-    }
-    if (walletData.type === "xprv") {
+        signer = node.deriveChild(addr.index);
+    } else 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
@@ -137,9 +154,18 @@ function getSignerForAddress(walletData, addrIndex, decryptedSecret) {
                     "is not a master key, so it cannot sign.",
             );
         }
-        return node.derivePath(BIP44_ETH_PATH).deriveChild(addrIndex);
+        signer = node.derivePath(BIP44_ETH_PATH).deriveChild(addr.index);
+    } else {
+        signer = new Wallet(decryptedSecret);
     }
-    return new Wallet(decryptedSecret);
+    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;
 }
 
 function isValidMnemonic(mnemonic) {

src/shared/walletDelete.js

@@ -14,7 +14,7 @@ function sameAddress(a, b) {
 
 // Forget every site permission held against the given addresses: the
 // remembered ones in `state`, and the connections approved without
-// "Remember", which only the background holds, in memory.
+// "Remember", which only the background holds, in session storage.
 function dropSitePermissions(state, addresses) {
     for (const addr of addresses) {
         delete state.allowedSites[addr];

tests/accountsChangedOpaqueOrigin.test.js

@@ -0,0 +1,167 @@
+// A page whose origin has no host is never told an address by accountsChanged
+// (https://git.eeqj.de/sneak/AutistMask/issues/564).
+//
+// When the user switches address, the background tells each open tab the new
+// active address if the site at the tab's URL is connected. A page at a
+// connected site's URL can still have another origin: one its server
+// sandboxes with a Content-Security-Policy has the origin "null", and every
+// request it makes is refused. Each test here switches the address in the real
+// background, takes the event it sent to a tab at the site's URL, and hands
+// that event to the real content script in a page of the given origin.
+
+const { networkById } = require("../src/shared/networks");
+const { makeStorageStub } = require("./support/storageStub");
+
+const ADDRESS = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+const SITE = "https://dapp.example";
+
+const EXT_URL = "chrome-extension://autistmask/";
+const FROM_POPUP = { url: EXT_URL + "src/popup/index.html" };
+
+// One address, with SITE remembered as allowed for it.
+function storedProfile() {
+    const mainnet = networkById("mainnet");
+    return {
+        hasWallet: true,
+        wallets: [
+            {
+                name: "Wallet 1",
+                type: "hd",
+                addresses: [
+                    { address: ADDRESS, balance: "0", tokenBalances: [] },
+                ],
+            },
+        ],
+        activeAddress: ADDRESS,
+        networkId: "mainnet",
+        rpcUrl: mainnet.defaultRpcUrl,
+        blockscoutUrl: mainnet.defaultBlockscoutUrl,
+        allowedSites: { [ADDRESS]: [SITE] },
+        deniedSites: {},
+        trackedTokens: [],
+    };
+}
+
+async function settle() {
+    for (let i = 0; i < 50; i++) await Promise.resolve();
+}
+
+afterEach(() => {
+    delete global.chrome;
+    delete global.window;
+    jest.resetModules();
+});
+
+// The popup tells the background the active address changed, and the one
+// open tab, at SITE's URL, is sent an event. That event is returned.
+async function eventSentToSiteTab() {
+    jest.resetModules();
+    jest.doMock("../src/shared/balances", () => ({
+        getProvider: () => ({}),
+        refreshBalances: jest.fn(async () => {}),
+    }));
+    jest.doMock("../src/shared/phishingDomains", () => ({
+        isPhishingDomain: () => false,
+    }));
+    jest.doMock("../src/shared/alarms", () => ({
+        BALANCE_REFRESH_ALARM: "balance",
+        BALANCE_REFRESH_PERIOD_MINUTES: 1,
+        ensureRecurringAlarms: jest.fn(async () => {}),
+        registerAlarmHandlers: jest.fn(),
+    }));
+
+    let messageListener = null;
+    const sentToTabs = [];
+    global.chrome = {
+        storage: makeStorageStub({ autistmask: storedProfile() }),
+        runtime: {
+            getURL: (path) => EXT_URL + path,
+            onMessage: {
+                addListener: (fn) => {
+                    messageListener = fn;
+                },
+            },
+            onConnect: { addListener: () => {} },
+            getPlatformInfo: (cb) => cb({ os: "linux" }),
+            lastError: null,
+        },
+        windows: {
+            remove: (id, cb) => {
+                if (cb) cb();
+            },
+            onRemoved: { addListener: () => {} },
+        },
+        tabs: {
+            query: (q, cb) => cb([{ id: 1, url: SITE + "/app" }]),
+            sendMessage: (tabId, msg, cb) => {
+                sentToTabs.push(msg);
+                if (cb) cb();
+            },
+        },
+        action: { setPopup: () => {} },
+    };
+
+    require("../src/background/index");
+    messageListener(
+        { type: "AUTISTMASK_ACTIVE_CHANGED" },
+        FROM_POPUP,
+        () => {},
+    );
+    await settle();
+
+    expect(sentToTabs).toHaveLength(1);
+    return sentToTabs[0];
+}
+
+// The content script in a page whose origin is `pageOrigin` is handed `event`
+// from the background. What it posts to the page is returned.
+function postedToPage(event, pageOrigin) {
+    jest.resetModules();
+    let eventListener = null;
+    const posted = [];
+    global.chrome = {
+        runtime: {
+            onMessage: {
+                addListener: (fn) => {
+                    eventListener = fn;
+                },
+            },
+        },
+    };
+    global.window = {
+        origin: pageOrigin,
+        addEventListener: () => {},
+        postMessage: (data) => posted.push(data),
+    };
+
+    require("../src/content/index");
+    eventListener(event);
+
+    return posted;
+}
+
+describe("accountsChanged after an address switch, at a connected site's URL", () => {
+    test("the site's own page is told the active address", async () => {
+        const event = await eventSentToSiteTab();
+
+        expect(postedToPage(event, SITE)).toEqual([
+            {
+                type: "AUTISTMASK_EVENT",
+                eventName: "accountsChanged",
+                data: [ADDRESS],
+            },
+        ]);
+    });
+
+    test("a page whose origin has no host is told no address", async () => {
+        const event = await eventSentToSiteTab();
+
+        expect(postedToPage(event, "null")).toEqual([
+            {
+                type: "AUTISTMASK_EVENT",
+                eventName: "accountsChanged",
+                data: [],
+            },
+        ]);
+    });
+});

tests/addressKey.test.js

@@ -0,0 +1,490 @@
+// 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/applyEnrichment.test.js

@@ -0,0 +1,19 @@
+// The token names and URLs in src/shared/tokenList.js are written from
+// script/lib/token-enrichment.json by script/lib/apply-enrichment.js
+// (`make apply-enrichment`). This fails when the committed list differs from
+// what the script writes from the committed data, and when the data or the
+// script's table of websites has an address that no entry in the list matches.
+
+const fs = require("fs");
+const path = require("path");
+
+const enrichment = require("../script/lib/token-enrichment.json");
+const { applyEnrichment } = require("../script/lib/apply-enrichment");
+
+test("src/shared/tokenList.js is what make apply-enrichment writes from the committed data", () => {
+    const committed = fs.readFileSync(
+        path.join(__dirname, "..", "src/shared/tokenList.js"),
+        "utf8",
+    );
+    expect(applyEnrichment(committed, enrichment)).toBe(committed);
+});

tests/approvalNonce.test.js

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

tests/approvalTx.test.js

@@ -9,7 +9,7 @@
 // requesting page or the RPC node can say turns it into an approval that
 // should never have been raised.
 
-const { Network, Wallet } = require("ethers");
+const { Network, Transaction, Wallet, toQuantity } = require("ethers");
 const {
     prepareApprovalTx,
     serializeApprovedTx,
@@ -138,6 +138,49 @@ describe("prepareApprovalTx", () => {
         expect(approved.maxFeePerGas).toBe("0x12a05f200");
     });
 
+    // `gas` is the JSON-RPC name for the gas limit and the one sites send.
+    // The node is still asked for its estimate, with the site's gas limit,
+    // because the estimate is the check that the transaction does not revert.
+    // It estimates 21000; the site's 200000 is what is shown and what is
+    // signed.
+    test("uses the gas limit a site sends as gas", async () => {
+        const estimateGas = jest.fn(async () => 21000n);
+        const approved = await prepareApprovalTx(
+            providerWith({ estimateGas }),
+            signer.address,
+            { ...TX_PARAMS, gas: "0x30d40" },
+        );
+        expect(estimateGas).toHaveBeenCalledWith(
+            expect.objectContaining({ gasLimit: 200000n }),
+        );
+        expect(approved.gasLimit).toBe("0x30d40");
+        const signed = Transaction.from(
+            await signer.signTransaction({ ...approved }),
+        );
+        expect(signed.gasLimit).toBe(200000n);
+    });
+
+    test("accepts gas and gasLimit that name the same number", async () => {
+        const approved = await prepareApprovalTx(
+            providerWith(),
+            signer.address,
+            { ...TX_PARAMS, gas: "0x30d40", gasLimit: 200000 },
+        );
+        expect(approved.gasLimit).toBe("0x30d40");
+    });
+
+    test("refuses gas and gasLimit that disagree", async () => {
+        await expect(
+            prepareApprovalTx(providerWith(), signer.address, {
+                ...TX_PARAMS,
+                gas: "0x30d40",
+                gasLimit: "0x5208",
+            }),
+        ).rejects.toThrow(
+            "The site asked for two different gas limits for this transaction.",
+        );
+    });
+
     test("carries an access list the request asked for", async () => {
         const approved = await prepareApprovalTx(
             providerWith(),
@@ -212,6 +255,15 @@ describe("prepareApprovalTx", () => {
         ).rejects.toThrow(/gas limit no network this wallet supports/);
     });
 
+    test("refuses a gas limit the site sent above the ceiling", async () => {
+        await expect(
+            prepareApprovalTx(providerWith(), signer.address, {
+                ...TX_PARAMS,
+                gas: toQuantity(MAX_GAS_LIMIT + 1n),
+            }),
+        ).rejects.toThrow(/gas limit no network this wallet supports/);
+    });
+
     // The combined bound at population: a gas limit and a fee that are each
     // under their own ceiling but multiply to thousands of ETH is refused
     // before the approval window opens, so the user is never shown a
@@ -251,6 +303,22 @@ describe("prepareApprovalTx", () => {
         expect(thrown.message).toMatch(/^[A-Z].*\.$/);
     });
 
+    test("fails back a reverting request that sends its own gas limit", async () => {
+        const reverting = providerWith({
+            estimateGas: async () => {
+                throw new Error("execution reverted: ERC20: transfer amount");
+            },
+        });
+        await expect(
+            prepareApprovalTx(reverting, signer.address, {
+                ...TX_PARAMS,
+                gas: "0x30d40",
+            }),
+        ).rejects.toThrow(
+            /^The transaction could not be prepared: execution reverted/,
+        );
+    });
+
     // Without a bound, an unreachable node leaves the page's promise pending
     // with nothing on screen to explain it.
     test("gives up on a node that never answers", async () => {
@@ -273,6 +341,28 @@ describe("prepareApprovalTx", () => {
             jest.useRealTimers();
         }
     });
+
+    // The estimate of a request carrying the site's gas limit is a call of its
+    // own, made before populating, and is bounded the same way.
+    test("gives up on a node that never answers the estimate of a request that sends its own gas limit", async () => {
+        jest.useFakeTimers();
+        try {
+            const hanging = providerWith({
+                estimateGas: () => new Promise(() => {}),
+            });
+            const pending = prepareApprovalTx(hanging, signer.address, {
+                ...TX_PARAMS,
+                gas: "0x30d40",
+            });
+            const settled = expect(pending).rejects.toThrow(
+                /did not answer in time/,
+            );
+            await jest.advanceTimersByTimeAsync(POPULATE_TIMEOUT_MS + 1);
+            await settled;
+        } finally {
+            jest.useRealTimers();
+        }
+    });
 });
 
 describe("serializeApprovedTx", () => {

tests/approvalVerify.test.js

@@ -58,7 +58,6 @@ const TX_PARAMS = {
     to: RECIPIENT,
     value: "0x2386f26fc10000",
     data: "0xdeadbeef",
-    gas: "0x5208",
 };
 
 // The values populateTransaction() fills in when the dApp fixed none of them.
@@ -1455,7 +1454,11 @@ 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, 0, SIGNER_KEY);
+        const localSigner = getSignerForAddress(
+            walletData,
+            { address: signer.address },
+            SIGNER_KEY,
+        );
         return localSigner.signTransaction({ ...approvedTx });
     }
 
@@ -1550,7 +1553,11 @@ 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, 0, OTHER_KEY);
+        const otherSigner = getSignerForAddress(
+            walletData,
+            { address: other.address },
+            OTHER_KEY,
+        );
         await expect(
             otherSigner.signTransaction({ ...approvedTx }),
         ).rejects.toThrow(/from address mismatch/);

tests/approvalWindow.test.js

@@ -45,3 +45,132 @@ test("the approval window shows no screen until the background describes the app
     expect(env.visibleViews()).toEqual(["approve-network"]);
     expect(env.pageErrors).toEqual([]);
 });
+
+// The background opens the approval window as wide as the page, but the
+// browser counts the window's frame in that width, and a screen taller than
+// the window takes a vertical scrollbar out of it too
+// (https://git.eeqj.de/sneak/AutistMask/issues/518). The browser suites run
+// without frames, and only the Firefox suite's sign prompt at a zoom other
+// than 100%, so the widening is checked here too.
+//
+// A window 396 screen pixels wide whose page is drawn at `drawn` screen pixels
+// to the page pixel. Widening it gives the page its new width, less the 15
+// screen pixels of the scrollbar the approval screen has, and then calls the
+// page's resize listeners, each of which asked to be called once.
+function windowsStub(type, drawn) {
+    const updates = [];
+    return {
+        updates,
+        getCurrent: (done) => done({ id: 7, type, width: 396 }),
+        update: (id, info, done) => {
+            updates.push({ id, info });
+            done({});
+            globalThis.document.documentElement.clientWidth = Math.floor(
+                (info.width - 15) / drawn,
+            );
+            const resized = globalThis.window.listeners.resize || [];
+            globalThis.window.listeners.resize = [];
+            for (const fn of resized) fn();
+        },
+    };
+}
+
+// The approval page's own tab is at `zoom`. Asked without a tab id, Firefox
+// answers for the window focused last, here a site's tab at 100%.
+function tabsStub(zoom) {
+    return {
+        getCurrent: (done) => done({ id: 11 }),
+        getZoom: (...args) => {
+            const done = args.pop();
+            done(args[0] === 11 ? zoom : 1);
+        },
+    };
+}
+
+// An approval window at `zoom`, `clientWidth` page pixels wide before its
+// screen is up, whose background holds its answer until the test gives it.
+async function bootZoomedApprovalWindow(windows, zoom, clientWidth) {
+    let answer = null;
+    const env = await bootPopup(unversionedValidProfile(), {
+        search: "?approval=approval-1",
+        runtime: {
+            connect: () => ({ postMessage: () => {} }),
+            sendMessage: (msg, reply) => {
+                if (msg.type === "AUTISTMASK_GET_APPROVAL") answer = reply;
+            },
+        },
+        windows,
+        tabs: tabsStub(zoom),
+        documentElement: { scrollWidth: 396, clientWidth },
+    });
+    return { env, answer };
+}
+
+test("at 150% zoom the approval window widens by what its screen lacks, scrollbar included", async () => {
+    const windows = windowsStub("popup", 1.5);
+    // At 150% a window 396 screen pixels wide shows 264 page pixels.
+    const { env, answer } = await bootZoomedApprovalWindow(windows, 1.5, 264);
+
+    // Not before there is a screen to fit.
+    expect(windows.updates).toEqual([]);
+
+    // The screen is taller than the window, so once it is up a vertical
+    // scrollbar takes 15 screen pixels, 10 page pixels at 150%.
+    env.document.documentElement.clientWidth = 254;
+    answer({
+        type: "network",
+        origin: "https://dapp.example",
+        currentNetworkId: "mainnet",
+        requestedNetworkId: "sepolia",
+        isPhishingDomain: false,
+    });
+    await settle();
+
+    // 396 - 254 = 142 page pixels short, which at 150% is 213 screen pixels.
+    // At the 100% of the site's tab it would be 142, and the screen would
+    // still not fit.
+    expect(env.visibleViews()).toEqual(["approve-network"]);
+    expect(windows.updates).toEqual([{ id: 7, info: { width: 609 } }]);
+    expect(env.document.documentElement.clientWidth).toBe(396);
+    expect(env.pageErrors).toEqual([]);
+});
+
+test("at 170% the approval window is widened again while its screen still falls short", async () => {
+    // Firefox reports 170% as 1.7 but draws a page pixel about 1.714 screen
+    // pixels wide, so a window 396 wide shows 231 page pixels.
+    const windows = windowsStub("popup", 1.714);
+    const { env, answer } = await bootZoomedApprovalWindow(windows, 1.7, 231);
+
+    // Less the scrollbar once the screen is up.
+    env.document.documentElement.clientWidth = 222;
+    answer({
+        type: "network",
+        origin: "https://dapp.example",
+        currentNetworkId: "mainnet",
+        requestedNetworkId: "sepolia",
+        isPhishingDomain: false,
+    });
+    await settle();
+
+    // 174 page pixels short, so 296 screen pixels wider at 1.7. That shows 394
+    // page pixels, still 2 short, so 4 screen pixels wider again.
+    expect(windows.updates).toEqual([
+        { id: 7, info: { width: 692 } },
+        { id: 7, info: { width: 696 } },
+    ]);
+    const page = env.document.documentElement;
+    expect(page.scrollWidth).toBeLessThanOrEqual(page.clientWidth);
+    expect(env.pageErrors).toEqual([]);
+});
+
+test("a connection prompt in the toolbar popup leaves the browser window alone", async () => {
+    const windows = windowsStub("normal", 1.5);
+    const { env, answer } = await bootZoomedApprovalWindow(windows, 1.5, 264);
+
+    answer({ origin: "https://dapp.example", isPhishingDomain: false });
+    await settle();
+
+    expect(env.visibleViews()).toEqual(["approve-site"]);
+    expect(windows.updates).toEqual([]);
+    expect(env.pageErrors).toEqual([]);
+});

tests/backgroundApproval.test.js

@@ -264,6 +264,7 @@ function loadBackground(options) {
                     connectListener = fn;
                 },
             },
+            getPlatformInfo: jest.fn((cb) => cb({ os: "linux" })),
             lastError: null,
         },
         windows: {
@@ -320,9 +321,10 @@ function loadBackground(options) {
     require("../src/background/index");
 
     // Send a message the way the browser would, and hand back whatever the
-    // handler passed to sendResponse.
-    function send(msg, sender) {
-        const sendResponse = jest.fn();
+    // handler passed to sendResponse. `onResponse`, when given, receives the
+    // answer when the handler sends it, as the sender's callback does.
+    function send(msg, sender, onResponse) {
+        const sendResponse = jest.fn(onResponse);
         const kept = messageListener(msg, sender || {}, sendResponse);
         return { sendResponse, kept };
     }
@@ -384,13 +386,13 @@ function loadBackground(options) {
 
     // The same through eth_signTypedData_v4, whose params name the address
     // first and the typed data second.
-    function requestTypedData() {
+    function requestTypedData(typedData = TYPED_DATA) {
         let rpcResult = null;
         messageListener(
             {
                 type: "AUTISTMASK_RPC",
                 method: "eth_signTypedData_v4",
-                params: [signer.address, TYPED_DATA],
+                params: [signer.address, typedData],
             },
             { origin: ORIGIN },
             (r) => {
@@ -878,6 +880,45 @@ describe("one transaction approval at a time", () => {
     });
 });
 
+// Chrome stops an idle worker, and the approvals in it go with it
+// (https://git.eeqj.de/sneak/AutistMask/issues/540). tests/e2e/slowApproval.js
+// shows the worker kept running in Chrome; this shows the calls stop once the
+// approval is answered, so the worker can stop again. Every kind of approval is
+// added through addPendingApproval(), which starts the calls, so a transaction
+// approval stands for all of them.
+describe("the worker keeps running while an approval is pending", () => {
+    test("an extension call every 20 seconds until the approval is answered", async () => {
+        const startTimer = jest
+            .spyOn(global, "setInterval")
+            .mockImplementation(() => 1);
+        const stopTimer = jest
+            .spyOn(global, "clearInterval")
+            .mockImplementation(() => {});
+        try {
+            const bg = loadBackground();
+            const calls = global.chrome.runtime.getPlatformInfo;
+            bg.requestTx();
+            await settle();
+            expect(startTimer).toHaveBeenCalledTimes(1);
+            expect(startTimer.mock.calls[0][1]).toBe(20000);
+            const tick = startTimer.mock.calls[0][0];
+
+            tick();
+            expect(calls).toHaveBeenCalledTimes(1);
+
+            // The user closes the approval window, which rejects it.
+            bg.closeWindow(1);
+            await settle();
+            tick();
+            expect(calls).toHaveBeenCalledTimes(1);
+            expect(stopTimer).toHaveBeenCalledWith(1);
+        } finally {
+            startTimer.mockRestore();
+            stopTimer.mockRestore();
+        }
+    });
+});
+
 // A page that asks again before the user has answered its last connection or
 // signature request is refused, instead of opening one more window per call.
 describe("one connection and one signature approval per site at a time", () => {
@@ -1121,9 +1162,12 @@ describe("a nonce collision is reported as a transaction that did not go out", (
         const pending = bg.requestTx();
         await settle();
 
+        // As ethers throws it: its own classification, and the node's
+        // JSON-RPC error under info.error.
         bg.broadcastTransaction.mockRejectedValue(
             Object.assign(new Error("nonce too low"), {
                 code: "NONCE_EXPIRED",
+                info: { error: { code: -32000, message: "nonce too low" } },
             }),
         );
         const answer = bg.send(
@@ -1142,8 +1186,10 @@ describe("a nonce collision is reported as a transaction that did not go out", (
             retryable: false,
             stage: "nonce",
         });
+        // The wallet's sentence, with the node's own code.
         expect(pending.result()).toEqual({
             error: {
+                code: -32000,
                 message: expect.stringMatching(
                     /transaction was not sent, because its nonce/,
                 ),
@@ -1193,6 +1239,7 @@ describe("a nonce collision is reported as a transaction that did not go out", (
         });
         expect(second.result()).toEqual({
             error: {
+                code: -32603,
                 message: expect.stringMatching(/nonce had already been used/),
             },
         });
@@ -1283,6 +1330,7 @@ describe("what the approval is verified against", () => {
         );
         expect(pending.result()).toEqual({
             error: {
+                code: -32603,
                 message: expect.stringMatching(/approved maximum fee per gas/),
             },
         });
@@ -1342,7 +1390,10 @@ describe("what the approval is verified against", () => {
             expect.objectContaining({ retryable: false, stage: "verify" }),
         );
         expect(pending.result()).toEqual({
-            error: { message: expect.stringMatching(/active address changed/) },
+            error: {
+                code: -32603,
+                message: expect.stringMatching(/active address changed/),
+            },
         });
     });
 
@@ -1486,7 +1537,10 @@ describe("what the approval is verified against", () => {
             }),
         );
         expect(pending.result()).toEqual({
-            error: { message: expect.stringMatching(/active address changed/) },
+            error: {
+                code: -32603,
+                message: expect.stringMatching(/active address changed/),
+            },
         });
     });
 
@@ -1494,8 +1548,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) {
-        const { domain, types, message } = JSON.parse(TYPED_DATA);
+    async function answerTypedData(bg, pending, typedData = TYPED_DATA) {
+        const { domain, types, message } = JSON.parse(typedData);
         delete types.EIP712Domain;
         const signature = await signer.signTypedData(domain, types, message);
         const answer = bg.send(
@@ -1536,9 +1590,49 @@ describe("what the approval is verified against", () => {
             error: refusal,
             retryable: false,
         });
-        expect(pending.result()).toEqual({ error: { message: refusal } });
+        expect(pending.result()).toEqual({
+            error: { code: -32603, 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: { code: -32603, message: refusal },
+            });
+        },
+    );
+
     test("a sign request from another address raises no approval at all", async () => {
         const bg = loadBackground();
         const pending = bg.requestSign(other.address);
@@ -1573,6 +1667,7 @@ describe("what the approval is verified against", () => {
 
         expect(pending.result()).toEqual({
             error: {
+                code: -32603,
                 message: expect.stringMatching(
                     /active address changed while this transaction was being prepared/,
                 ),
@@ -1595,8 +1690,11 @@ describe("what the approval is verified against", () => {
         const pending = bg.requestTx();
         await settle();
 
+        // A failure with no node error in it is answered as the wallet's own;
+        // tests/rpcErrorCodes.test.js has the node's own revert.
         expect(pending.result()).toEqual({
             error: {
+                code: -32603,
                 message: expect.stringMatching(
                     /could not be prepared.*execution reverted/,
                 ),
@@ -1606,6 +1704,55 @@ describe("what the approval is verified against", () => {
     });
 });
 
+// eth_sign names the address first and the data second, the reverse of
+// personal_sign, and is answered as the JSON-RPC specification defines it:
+// with an EIP-191 personal message signature over the data, the same
+// signature personal_sign returns
+// (https://git.eeqj.de/sneak/AutistMask/issues/409). The signature below is
+// made by the test; that the sign screen makes the same one is tested in
+// tests/ethSign.test.js.
+describe("eth_sign", () => {
+    test("is read address first, and returns a personal message signature over the data", async () => {
+        const bg = loadBackground();
+        const page = bg.send(
+            {
+                type: "AUTISTMASK_RPC",
+                method: "eth_sign",
+                params: [signer.address, MESSAGE],
+            },
+            { origin: ORIGIN },
+        );
+        await settle();
+        const id = approvalIdIn(bg.created.map((c) => c.url));
+
+        const details = bg.send(
+            { type: "AUTISTMASK_GET_APPROVAL", id },
+            { url: bg.fromPopup.url },
+        );
+        const { signParams } = details.sendResponse.mock.calls[0][0];
+        expect(signParams).toMatchObject({
+            method: "eth_sign",
+            message: MESSAGE,
+            from: signer.address,
+        });
+        expect(signParams.dangerWarning).toBe(
+            "This site used the older eth_sign method. " +
+                "The data will be signed as a personal message.",
+        );
+
+        const signature = await signer.signMessage(
+            Buffer.from(MESSAGE.slice(2), "hex"),
+        );
+        bg.send(
+            { type: "AUTISTMASK_SIGN_RESPONSE", id, approved: true, signature },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+
+        expect(page.sendResponse).toHaveBeenCalledWith({ result: signature });
+    });
+});
+
 // The interlock must not cost the retry the approval exists to allow.
 describe("the interlock releases a failed attempt", () => {
     test("a retryable failure before the broadcast leaves the approval usable", async () => {
@@ -2469,9 +2616,9 @@ async function siteAccounts(bg, origin) {
     return sendResponse.mock.calls[0][0];
 }
 
-// A site connected without "Remember" is held only in the background's memory,
-// keyed to the address it was connected to. Removing that address, or the
-// wallet holding it, must end the connection as part of the removal itself.
+// A site connected without "Remember" is held only in the background's session
+// storage, keyed to the address it was connected to. Removing that address, or
+// the wallet holding it, must end the connection as part of the removal itself.
 // The accountsChanged broadcast the views send afterwards also clears it, but
 // only when the active address moved, and nothing waits for it to arrive.
 //
@@ -2650,8 +2797,7 @@ describe("removing a site in Settings disconnects it", () => {
         const element = (id) => (lists[id] ||= fakeSiteList());
         global.document = { getElementById: element };
         global.chrome.runtime.sendMessage = (msg, callback) => {
-            const { sendResponse } = bg.send(msg, bg.fromPopup);
-            if (callback) callback(sendResponse.mock.calls[0]?.[0]);
+            bg.send(msg, bg.fromPopup, callback);
         };
         await require("../src/shared/state").loadState();
         await require("../src/popup/views/settings").renderSiteLists();
@@ -2805,7 +2951,7 @@ describe("where an approval window opens", () => {
         await settle();
 
         expect(bg.created).toHaveLength(1);
-        expect(bg.created[0]).toMatchObject({ left: 460, top: 60 });
+        expect(bg.created[0]).toMatchObject({ left: 442, top: 60 });
     });
 
     test("not centred on an approval window the user was last in", async () => {
@@ -2822,7 +2968,7 @@ describe("where an approval window opens", () => {
         bg.requestSign();
         await settle();
 
-        // Centred, it would be at left 900, the position the browser refused.
+        // Centred, it would be at left 882, the position the browser refused.
         expect(bg.created).toHaveLength(1);
         expect(bg.created[0].left).toBeUndefined();
         expect(bg.created[0].top).toBeUndefined();
@@ -2844,7 +2990,7 @@ describe("where an approval window opens", () => {
         await settle();
 
         expect(bg.created).toHaveLength(2);
-        expect(bg.created[0]).toMatchObject({ left: 1520, top: 750 });
+        expect(bg.created[0]).toMatchObject({ left: 1502, top: 750 });
         expect(bg.created[1].left).toBeUndefined();
         expect(bg.created[1].top).toBeUndefined();
 

tests/confirmTxNetworkSwitch.test.js

@@ -0,0 +1,259 @@
+// A transfer is sent only on the network its confirmation screen was drawn for
+// (https://git.eeqj.de/sneak/AutistMask/issues/524).
+//
+// Settings is reachable from the confirmation screen, and Back from it only
+// unhides the screen, still labelled for the network it was drawn for. Sign &
+// Send used to take the network at the moment of the click, so 1 SepoliaETH
+// reviewed on Sepolia went out as 1 ETH on mainnet once mainnet was chosen in
+// Settings in between.
+//
+// Driven through the real confirmation screen, signer and chain switch, with
+// only the node and the DOM stubbed. The stub node is on the network its
+// provider was built for, so a broadcast records the network it went to.
+
+"use strict";
+
+// The signed transactions the stub node was handed, with its network's chain id.
+const mockNode = { broadcast: [] };
+
+jest.mock("ethers", () => {
+    const actual = jest.requireActual("ethers");
+    class StubProvider {
+        constructor(url, network) {
+            this.network = network;
+        }
+        async getNetwork() {
+            return this.network;
+        }
+        async getFeeData() {
+            return {
+                maxFeePerGas: 20000000000n,
+                maxPriorityFeePerGas: 1000000000n,
+                gasPrice: 10000000000n,
+            };
+        }
+        async estimateGas() {
+            return 21000n;
+        }
+        async getCode() {
+            return "0x";
+        }
+        async getTransactionCount() {
+            return 1;
+        }
+        async lookupAddress() {
+            return null;
+        }
+        async broadcastTransaction(signed) {
+            mockNode.broadcast.push({ chainId: this.network.chainId, signed });
+            return { hash: "0x" + "ab".repeat(32) };
+        }
+    }
+    return { ...actual, JsonRpcProvider: StubProvider };
+});
+
+jest.mock("../src/shared/log", () => ({
+    log: {
+        debugf: () => {},
+        infof: () => {},
+        warnf: () => {},
+        errorf: () => {},
+    },
+    debugFetch: jest.fn(async () => ({
+        ok: true,
+        status: 200,
+        json: async () => ({ items: [] }),
+    })),
+    urlOrigin: () => "",
+    setRuntimeDebug: () => {},
+    isDebug: () => false,
+}));
+
+// 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(),
+}));
+
+global.fetch = jest.fn(() => {
+    throw new Error("tests must not perform network requests");
+});
+
+const { makeStorageStub } = require("./support/storageStub");
+global.chrome = { storage: makeStorageStub(), runtime: { sendMessage() {} } };
+
+// A stub DOM: every id resolves to a recording element.
+const elements = new Map();
+
+function makeEl(id) {
+    const handlers = new Map();
+    return {
+        id,
+        textContent: "",
+        innerHTML: "",
+        value: "",
+        disabled: false,
+        style: {},
+        dataset: {},
+        classList: {
+            add() {},
+            remove() {},
+            toggle() {},
+            contains: () => false,
+        },
+        handlers,
+        addEventListener(name, fn) {
+            handlers.set(name, fn);
+        },
+        querySelectorAll: () => [],
+        querySelector: () => null,
+        remove() {},
+        focus() {},
+    };
+}
+
+global.document = {
+    getElementById(id) {
+        if (!elements.has(id)) elements.set(id, makeEl(id));
+        return elements.get(id);
+    },
+    createElement: (tag) => makeEl(tag),
+    body: { prepend() {}, appendChild() {} },
+    addEventListener() {},
+};
+global.navigator = { clipboard: { writeText() {} } };
+
+const { BaseWallet, Transaction, Wallet } = require("ethers");
+const { encryptWithPassword } = require("../src/shared/vault");
+const { state, loadState } = require("../src/shared/state");
+const { onChainSwitch } = require("../src/shared/chainSwitch");
+const { NETWORKS } = require("../src/shared/networks");
+const txStatus = require("../src/popup/views/txStatus");
+const confirmTx = require("../src/popup/views/confirmTx");
+
+const PRIVATE_KEY = "0x" + "11".repeat(32);
+const HOLDER = new Wallet(PRIVATE_KEY).address;
+const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
+const PASSWORD = "correct horse battery staple";
+
+function el(id) {
+    return global.document.getElementById(id);
+}
+
+let encryptedSecret;
+let signTransaction;
+
+beforeAll(async () => {
+    await loadState();
+    encryptedSecret = await encryptWithPassword(PRIVATE_KEY, PASSWORD);
+});
+
+beforeEach(() => {
+    elements.clear();
+    mockNode.broadcast = [];
+    txStatus.showWait.mockClear();
+    txStatus.showError.mockClear();
+    signTransaction = jest.spyOn(BaseWallet.prototype, "signTransaction");
+});
+
+afterEach(() => {
+    signTransaction.mockRestore();
+});
+
+// Show the confirmation screen for 1 of the native token on `networkId`, as
+// Review on the Send screen does, with its fee estimate settled.
+async function review(networkId) {
+    await onChainSwitch(networkId);
+    state.wallets = [
+        {
+            type: "key",
+            name: "Wallet 1",
+            encryptedSecret,
+            addresses: [{ address: HOLDER, balance: "5.0" }],
+        },
+    ];
+    state.selectedWallet = 0;
+    state.selectedAddress = 0;
+    confirmTx.init({});
+    confirmTx.show({
+        from: HOLDER,
+        to: RECIPIENT,
+        ensName: null,
+        amount: "1",
+        token: "ETH",
+        balance: "5.0",
+        tokenSymbol: null,
+        tokenBalance: null,
+        tokenDecimals: null,
+        max: false,
+    });
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
+}
+
+async function signAndSend() {
+    el("confirm-tx-password").value = PASSWORD;
+    await el("btn-confirm-send").handlers.get("click")();
+}
+
+test("a transfer reviewed on Sepolia and sent goes out on Sepolia", async () => {
+    await review("sepolia");
+    expect(el("confirm-type").textContent).toBe("Native SepoliaETH transfer");
+    expect(el("btn-confirm-send").disabled).toBe(false);
+    await signAndSend();
+    expect(mockNode.broadcast).toHaveLength(1);
+    expect(mockNode.broadcast[0].chainId).toBe(11155111n);
+    expect(Transaction.from(mockNode.broadcast[0].signed).chainId).toBe(
+        11155111n,
+    );
+    expect(txStatus.showWait).toHaveBeenCalledTimes(1);
+});
+
+describe.each([
+    ["sepolia", "mainnet", "SepoliaETH"],
+    ["mainnet", "sepolia", "ETH"],
+])(
+    "a transfer reviewed on %s, with %s chosen in Settings before Sign & Send",
+    (reviewedOn, switchedTo, symbol) => {
+        test("is neither signed nor sent, and the screen says why", async () => {
+            await review(reviewedOn);
+            expect(el("confirm-type").textContent).toBe(
+                "Native " + symbol + " transfer",
+            );
+            // Settings' network select, then Back, which only unhides the
+            // screen as it was drawn.
+            await onChainSwitch(switchedTo);
+            await signAndSend();
+
+            expect(signTransaction).not.toHaveBeenCalled();
+            expect(mockNode.broadcast).toEqual([]);
+            expect(txStatus.showWait).not.toHaveBeenCalled();
+            expect(txStatus.showError).not.toHaveBeenCalled();
+            expect(el("confirm-errors").style.visibility).toBe("visible");
+            expect(el("confirm-errors").innerHTML).toContain(
+                "The active network changed after this transaction was" +
+                    " reviewed, so it was not sent. Please go back and review" +
+                    " it again.",
+            );
+        });
+    },
+);
+
+// The check in the click handler tells the user; the send itself carries the
+// chain id the screen was drawn for, so a signer on another network's node
+// cannot sign it even if the network changes after that check.
+test("the send is refused by a signer on another network's node", async () => {
+    const { getProvider } = require("../src/shared/balances");
+    const signer = new Wallet(PRIVATE_KEY).connect(
+        getProvider("https://rpc.example.invalid", "mainnet"),
+    );
+    await expect(
+        confirmTx.populateVerifyAndSend(signer, {
+            token: "ETH",
+            to: RECIPIENT,
+            amount: "1",
+            chainId: NETWORKS.sepolia.chainId,
+        }),
+    ).rejects.toThrow("transaction chainId mismatch");
+    expect(signTransaction).not.toHaveBeenCalled();
+    expect(mockNode.broadcast).toEqual([]);
+});

tests/connectedSitesWorkerRestart.test.js

@@ -0,0 +1,354 @@
+// A site allowed without "Remember my choice for this site" stays connected
+// when the background worker is stopped and started again
+// (https://git.eeqj.de/sneak/AutistMask/issues/526).
+//
+// Chrome stops the worker after about 30 seconds idle and evaluates the
+// module afresh on the next event, so nothing held at module scope survives
+// it. Such a connection used to be held exactly there, and so lasted until the
+// first idle spell. Each test here makes the connection in one load of the
+// background, loads the module afresh over the same storage, as the browser
+// does, and asks the new one. The paths that end a connection are driven after
+// that restart, so each is shown to end what the earlier worker stored.
+
+const { networkById } = require("../src/shared/networks");
+const { makeStorageStub } = require("./support/storageStub");
+const {
+    removeAddressFromState,
+    removeWalletFromState,
+} = require("../src/shared/walletDelete");
+
+const ADDRESS = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+const OTHER_ADDRESS = "0x70997970C51812dc3A010C7d01b50e0d17dc79C8";
+
+const SITE = "https://dapp.example";
+const OTHER_SITE = "https://other.example";
+
+const EXT_URL = "chrome-extension://autistmask/";
+const FROM_POPUP = { url: EXT_URL + "src/popup/index.html" };
+
+// One wallet with two addresses, so that one of them can be removed, and no
+// remembered sites, so that every connection here is one made without
+// "Remember".
+function storedProfile() {
+    const mainnet = networkById("mainnet");
+    return {
+        hasWallet: true,
+        wallets: [
+            {
+                name: "Wallet 1",
+                type: "hd",
+                addresses: [
+                    { address: ADDRESS, balance: "0", tokenBalances: [] },
+                    { address: OTHER_ADDRESS, balance: "0", tokenBalances: [] },
+                ],
+            },
+        ],
+        activeAddress: ADDRESS,
+        networkId: "mainnet",
+        rpcUrl: mainnet.defaultRpcUrl,
+        blockscoutUrl: mainnet.defaultBlockscoutUrl,
+        allowedSites: {},
+        deniedSites: {},
+        trackedTokens: [],
+    };
+}
+
+async function settle() {
+    for (let i = 0; i < 50; i++) await Promise.resolve();
+}
+
+afterEach(() => {
+    delete global.chrome;
+    jest.resetModules();
+});
+
+// Load the background module afresh, as the browser does when it starts the
+// worker, over `storage`. The storage stub stands in for the browser's own
+// storage, local and session, so it outlives each load.
+function startWorker(storage) {
+    jest.resetModules();
+    jest.doMock("../src/shared/balances", () => ({
+        getProvider: () => ({}),
+        refreshBalances: jest.fn(async () => {}),
+    }));
+    jest.doMock("../src/shared/phishingDomains", () => ({
+        isPhishingDomain: () => false,
+    }));
+    jest.doMock("../src/shared/alarms", () => ({
+        BALANCE_REFRESH_ALARM: "balance",
+        BALANCE_REFRESH_PERIOD_MINUTES: 1,
+        ensureRecurringAlarms: jest.fn(async () => {}),
+        registerAlarmHandlers: jest.fn(),
+    }));
+
+    let messageListener = null;
+    let connectListener = null;
+    // Every URL the toolbar popup was set to open: a site's connection prompt
+    // is shown there, so this is where its approval id appears.
+    const toolbarPopups = [];
+    const windowsCreated = [];
+    const sentToTabs = [];
+
+    global.chrome = {
+        storage,
+        runtime: {
+            getURL: (path) => EXT_URL + path,
+            onMessage: {
+                addListener: (fn) => {
+                    messageListener = fn;
+                },
+            },
+            onConnect: {
+                addListener: (fn) => {
+                    connectListener = fn;
+                },
+            },
+            getPlatformInfo: (cb) => cb({ os: "linux" }),
+            // What the popup sends reaches the worker from the extension's own
+            // page.
+            sendMessage: (msg, callback) => {
+                messageListener(msg, FROM_POPUP, callback || (() => {}));
+            },
+            lastError: null,
+        },
+        windows: {
+            getLastFocused: (cb) => cb(null),
+            create: (options, cb) => {
+                windowsCreated.push(options);
+                cb({ id: windowsCreated.length });
+            },
+            remove: (id, cb) => {
+                if (cb) cb();
+            },
+            onRemoved: { addListener: () => {} },
+        },
+        tabs: {
+            query: (q, cb) => cb([{ id: 1, url: SITE + "/app" }]),
+            sendMessage: (tabId, msg, cb) => {
+                sentToTabs.push(msg);
+                if (cb) cb();
+            },
+        },
+        action: {
+            setPopup: (o) => {
+                toolbarPopups.push(o.popup);
+            },
+            openPopup: () => Promise.resolve(),
+        },
+    };
+
+    require("../src/background/index");
+
+    // A request from a site, answered once the worker has had time to answer.
+    async function rpc(method, origin, params) {
+        let response = null;
+        messageListener(
+            { type: "AUTISTMASK_RPC", method, params: params || [] },
+            { origin },
+            (r) => {
+                response = r;
+            },
+        );
+        await settle();
+        return response;
+    }
+
+    // A message from the popup, and the worker's answer to it.
+    async function fromPopup(msg) {
+        let response;
+        messageListener(msg, FROM_POPUP, (r) => {
+            response = r;
+        });
+        await settle();
+        return response;
+    }
+
+    // The site asks to connect, and the user allows it in the prompt with
+    // "Remember my choice for this site" left unchecked.
+    async function connectWithoutRemember(origin) {
+        let response = null;
+        messageListener(
+            { type: "AUTISTMASK_RPC", method: "eth_requestAccounts" },
+            { origin },
+            (r) => {
+                response = r;
+            },
+        );
+        await settle();
+        const id = new URL(toolbarPopups.at(-1), EXT_URL).searchParams.get(
+            "approval",
+        );
+        const decisionListeners = [];
+        const port = {
+            name: "approval:" + id,
+            sender: { url: EXT_URL + "src/popup/index.html?approval=" + id },
+            onMessage: { addListener: (fn) => decisionListeners.push(fn) },
+            onDisconnect: { addListener: () => {} },
+        };
+        connectListener(port);
+        for (const fn of decisionListeners) {
+            fn(
+                {
+                    type: "AUTISTMASK_APPROVAL_DECISION",
+                    approved: true,
+                    remember: false,
+                },
+                port,
+            );
+        }
+        await settle();
+        return response;
+    }
+
+    return {
+        rpc,
+        fromPopup,
+        connectWithoutRemember,
+        windowsCreated,
+        sentToTabs,
+    };
+}
+
+// A site connected without "Remember" in one worker, and the worker started
+// again over the same storage, where the site is still connected.
+async function connectedThenRestarted() {
+    const storage = makeStorageStub({ autistmask: storedProfile() });
+    const first = startWorker(storage);
+    expect(await first.connectWithoutRemember(SITE)).toEqual({
+        result: [ADDRESS],
+    });
+    const worker = startWorker(storage);
+    expect(await worker.rpc("eth_accounts", SITE)).toEqual({
+        result: [ADDRESS],
+    });
+    return { storage, worker };
+}
+
+describe("a site allowed without Remember, after the worker restarts", () => {
+    test("is still told the address, and is not asked again", async () => {
+        const { worker } = await connectedThenRestarted();
+
+        expect(await worker.rpc("eth_accounts", SITE)).toEqual({
+            result: [ADDRESS],
+        });
+        expect(await worker.rpc("eth_requestAccounts", SITE)).toEqual({
+            result: [ADDRESS],
+        });
+    });
+
+    test("is still listed under Connected Sites in Settings", async () => {
+        const { worker } = await connectedThenRestarted();
+
+        expect(
+            await worker.fromPopup({ type: "AUTISTMASK_GET_CONNECTED_SITES" }),
+        ).toEqual([SITE]);
+    });
+
+    test("may still ask for a signature", async () => {
+        // Refused with 4100 before the fix. Allowed, it raises the signing
+        // prompt and waits on the user.
+        const { worker } = await connectedThenRestarted();
+
+        const response = await worker.rpc("personal_sign", SITE, [
+            "0x48656c6c6f",
+            ADDRESS,
+        ]);
+
+        expect(response).toBeNull();
+        expect(worker.windowsCreated).toHaveLength(1);
+    });
+
+    test("is not connected after the browser restarts", async () => {
+        // The browser empties session storage when it closes; the wallet's
+        // own storage keeps nothing of the connection.
+        const { storage } = await connectedThenRestarted();
+        const afterBrowserRestart = startWorker(
+            makeStorageStub({ autistmask: storage.read("autistmask") }),
+        );
+
+        expect(await afterBrowserRestart.rpc("eth_accounts", SITE)).toEqual({
+            result: [],
+        });
+    });
+});
+
+describe("each way a connection allowed without Remember ends, after the worker restarts", () => {
+    test("removing the site in Settings", async () => {
+        const { worker } = await connectedThenRestarted();
+        expect(await worker.connectWithoutRemember(OTHER_SITE)).toEqual({
+            result: [ADDRESS],
+        });
+
+        await worker.fromPopup({
+            type: "AUTISTMASK_REMOVE_SITE",
+            origin: SITE,
+        });
+
+        expect(await worker.rpc("eth_accounts", SITE)).toEqual({ result: [] });
+        expect(worker.sentToTabs).toEqual([
+            {
+                type: "AUTISTMASK_EVENT",
+                eventName: "accountsChanged",
+                data: [],
+            },
+        ]);
+        expect(
+            await worker.fromPopup({ type: "AUTISTMASK_GET_CONNECTED_SITES" }),
+        ).toEqual([OTHER_SITE]);
+        expect(await worker.rpc("eth_accounts", OTHER_SITE)).toEqual({
+            result: [ADDRESS],
+        });
+    });
+
+    test("switching to another address", async () => {
+        // Switched away and back again, so the answer turns on the connection
+        // having ended rather than on which address is active.
+        const { storage, worker } = await connectedThenRestarted();
+        const switched = { ...storage.read("autistmask") };
+
+        switched.activeAddress = OTHER_ADDRESS;
+        storage.write("autistmask", switched);
+        await worker.fromPopup({ type: "AUTISTMASK_ACTIVE_CHANGED" });
+        switched.activeAddress = ADDRESS;
+        storage.write("autistmask", switched);
+
+        expect(await worker.rpc("eth_accounts", SITE)).toEqual({ result: [] });
+        expect(
+            await worker.fromPopup({ type: "AUTISTMASK_GET_CONNECTED_SITES" }),
+        ).toEqual([]);
+    });
+
+    // The two below ask while storage still names the removed address as
+    // active, because the popup has not saved yet, so the answer turns on the
+    // connection alone.
+    test("removing the connected address", async () => {
+        const { storage, worker } = await connectedThenRestarted();
+
+        const popupState = storage.read("autistmask");
+        expect(removeAddressFromState(popupState, 0, 0).removed).toBe(true);
+        await settle();
+
+        expect(await worker.rpc("eth_accounts", SITE)).toEqual({ result: [] });
+    });
+
+    test("removing the wallet holding the connected address", async () => {
+        const { storage, worker } = await connectedThenRestarted();
+
+        removeWalletFromState(storage.read("autistmask"), 0);
+        await settle();
+
+        expect(await worker.rpc("eth_accounts", SITE)).toEqual({ result: [] });
+    });
+
+    test("removing a different address leaves it connected", async () => {
+        const { storage, worker } = await connectedThenRestarted();
+
+        const popupState = storage.read("autistmask");
+        expect(removeAddressFromState(popupState, 0, 1).removed).toBe(true);
+        await settle();
+
+        expect(await worker.rpc("eth_accounts", SITE)).toEqual({
+            result: [ADDRESS],
+        });
+    });
+});

tests/e2e/dapp.js

@@ -1,25 +1,29 @@
-// A loopback dApp origin and stub Ethereum node for the Firefox suite.
+// A loopback dApp origin and stub Ethereum node, used by the two browser
+// programs that have no Playwright to answer the browser's requests for them:
+// the Firefox suite (tests/e2e/firefox/run.js) and the Chrome program that
+// leaves approvals open for seven minutes (tests/e2e/slowApproval.js). The
+// Chrome suite in run.js answers its requests through network.js instead.
 //
 // The Firefox container runs with --network none, and the harness note in
-// driver.js records the consequence: with no http:// origin in reach, no
-// content script was ever injected, so content-script behaviour was
+// firefox/driver.js records the consequence: with no http:// origin in reach,
+// no content script was ever injected, so content-script behaviour was
 // UNVERIFIED and the dApp flows could not be driven at all.
 //
 // --network none removes every interface except loopback, and loopback is
 // enough. This serves the page and the JSON-RPC endpoint from 127.0.0.1
-// inside the same container Firefox runs in, so the dApp round trips execute
-// against a real http:// origin and the run stays as offline as it was: the
-// only reachable peer is this process.
+// inside the same container the browser runs in, so the dApp round trips
+// execute against a real http:// origin and the run stays as offline as it
+// was: the only reachable peer is this process.
 //
 // The page itself is not written twice. DAPP_HTML comes from the Chrome
-// suite's fixture, so both harnesses drive the same __dapp API and the same
-// message log.
+// suite's fixture, so every browser program drives the same __dapp API and
+// the same message log.
 //
-// Unlike driver.js this file does use ethers, and it has to: the node has to
-// answer eth_sendRawTransaction with the hash ethers computes for the
+// Unlike firefox/driver.js this file does use ethers, and it has to: the node
+// has to answer eth_sendRawTransaction with the hash ethers computes for the
 // artifact it was handed, or provider.broadcastTransaction() refuses the
-// answer, and the suite recovers signatures itself rather than believing the
-// extension's own verdict.
+// answer, and both programs recover signatures themselves rather than
+// believing the extension's own verdict.
 
 "use strict";
 
@@ -27,7 +31,7 @@ const http = require("http");
 
 const { Transaction } = require("ethers");
 
-const { DAPP_HTML } = require("../network");
+const { DAPP_HTML } = require("./network");
 
 // The same fee shape the Chrome suite uses, for the same reason: it has to
 // pass the ceilings in src/shared/approvalVerify.js and it has to leave the
@@ -170,11 +174,11 @@ async function startDappServer() {
                     const payload = JSON.stringify(handleRpcBody(body, state));
                     res.writeHead(200, {
                         "Content-Type": "application/json",
-                        // The extension fetches this from its background
-                        // page, whose origin is moz-extension://. Without CORS
-                        // the fetch fails and every transaction assertion
-                        // fails for a reason that has nothing to do with the
-                        // wallet.
+                        // In Firefox the extension fetches this from its
+                        // background page, whose origin is moz-extension://.
+                        // Without CORS the fetch fails and every transaction
+                        // assertion fails for a reason that has nothing to do
+                        // with the wallet.
                         "Access-Control-Allow-Origin": "*",
                     });
                     res.end(payload);
@@ -193,8 +197,8 @@ async function startDappServer() {
         }
 
         // An empty favicon rather than a 404: a 404 is a page error in
-        // Firefox's console under some settings, and the suite fails the run
-        // on those.
+        // Firefox's console under some settings, and the Firefox suite fails
+        // the run on those.
         if (url.pathname === "/favicon.ico") {
             res.writeHead(200, { "Content-Type": "image/x-icon" });
             res.end("");

tests/e2e/firefox/driver.js

@@ -467,7 +467,7 @@ class Driver {
 // src/background/index.js, which kills the background page outright, fails
 // the run.
 //
-// Content scripts ARE now exercised: tests/e2e/firefox/dapp.js serves a page
+// Content scripts ARE now exercised: tests/e2e/dapp.js serves a page
 // from loopback, which survives --network none, and the suite drives the
 // EIP-1193 round trips through the content script injected into it. What is
 // still unproven is the CAPTURE, not the execution — no probe has forced a

tests/e2e/firefox/run.js

@@ -17,13 +17,13 @@
 // note in driver.js), so the two backends have no common substrate to
 // abstract over. Duplicated steps do not pay for a shim; revisit if this
 // suite grows to where they do. What IS shared is the dApp page fixture
-// itself — DAPP_HTML, served here from loopback by dapp.js — so an assertion
-// about the __dapp API means the same thing on both browsers.
+// itself — DAPP_HTML, served here from loopback by tests/e2e/dapp.js — so an
+// assertion about the __dapp API means the same thing on both browsers.
 //
 // The dApp steps need an http:// origin, which --network none was thought to
 // rule out. It does not: loopback survives it, so the page and the stub node
 // are served from 127.0.0.1 inside the container and the run reaches nothing
-// but this process. See tests/e2e/firefox/dapp.js.
+// but this process. See tests/e2e/dapp.js.
 //
 // LIMITATION, and the difference from the Chrome suite worth knowing: error
 // capture here is POLL-BASED, not event-streamed. The console service is
@@ -61,7 +61,7 @@ const {
 } = require("ethers");
 
 const { ConsoleErrors, EXTENSION_ORIGIN, start, sleep } = require("./driver");
-const { startDappServer } = require("./dapp");
+const { startDappServer } = require("../dapp");
 const { STUB_COUNTERPARTY } = require("../network");
 const { NETWORKS } = require("../../../src/shared/networks");
 const {
@@ -394,6 +394,26 @@ async function waitForApprovalWindow(d, timeout = 30000) {
     }
 }
 
+// Firefox keeps one zoom per site, so a zoom set on the popup's tab holds for
+// every page of the extension, the approval windows included.
+async function setExtensionZoom(env, zoom) {
+    const d = env.driver;
+    await d.switchToWindow(env.popupWindow);
+    const outcome = await d.executeAsync(
+        `const done = arguments[arguments.length - 1];
+         const zoom = arguments[0];
+         browser.tabs
+             .getCurrent()
+             .then((tab) => browser.tabs.setZoom(tab.id, zoom))
+             .then(() => done({}), (e) => done({ error: String(e) }));`,
+        [zoom],
+    );
+    assert(
+        outcome && !outcome.error,
+        "could not set the extension's zoom: " + (outcome && outcome.error),
+    );
+}
+
 function startRequest(d, key, method, params) {
     return d.execute(
         "window.__dapp.start(arguments[0], arguments[1], arguments[2]);" +
@@ -633,6 +653,14 @@ step(
     "personal_sign returns a signature that recovers to the address",
     async (env) => {
         const d = env.driver;
+        // The window is opened as wide as the page, and widened once the
+        // screen is up if it still scrolls sideways
+        // (https://git.eeqj.de/sneak/AutistMask/issues/518). This suite is
+        // where that is checked: the Chrome suite's approval windows open at
+        // 1280x720 whatever width the extension asks for. At 170%, one of
+        // Firefox's zoom steps, the page is drawn a little larger than the
+        // 1.7 Firefox reports, so a single widening leaves it a pixel short.
+        await setExtensionZoom(env, 1.7);
         await d.switchToWindow(env.dappWindow);
         await startRequest(d, "sign", "personal_sign", [SIGN_HEX, env.address]);
 
@@ -640,6 +668,12 @@ step(
         await d.switchToWindow(popup);
         await d.waitVisible("#view-approve-sign");
 
+        await d.waitFor(
+            "the sign prompt to fit its window without scrolling sideways",
+            "return document.documentElement.scrollWidth <=" +
+                " document.documentElement.clientWidth;",
+        );
+
         const screen = await d.execute(
             `return {
              origin: document.getElementById("approve-sign-origin").textContent,
@@ -674,6 +708,7 @@ step(
 
         await d.switchToWindow(env.dappWindow);
         const outcome = await settleRequest(d, "sign");
+        await setExtensionZoom(env, 1);
         assert(
             outcome.settled === "resolved",
             "personal_sign did not resolve: " + JSON.stringify(outcome),

tests/e2e/network.js

@@ -94,7 +94,7 @@ function word(value) {
 // is the real inpage provider and not a copy the harness wired up.
 //
 // DAPP_HTML below is exported and served verbatim by the Firefox suite too
-// (tests/e2e/firefox/dapp.js), from a loopback origin rather than through a
+// (tests/e2e/dapp.js), from a loopback origin rather than through a
 // route handler. The two suites drive different browsers over different
 // protocols, but the page they drive — the __dapp API, the message log — is
 // one fixture, so an assertion written against it means the same thing on

tests/e2e/run.js

@@ -3857,11 +3857,12 @@ test("eth_requestAccounts approved returns the selected address (#183)", async (
             shown.toLowerCase().includes(env.expectedAddress.toLowerCase()),
             "the site prompt shows the wrong address: " + JSON.stringify(shown),
         );
+        // The text above is there even when the row is too narrow to show it
+        // all; this measures that the whole address is visible (#517).
+        await assertAddressesFit(popup, "the connection prompt");
 
-        // Remembered, so the connection survives a background worker that MV3
-        // terminates after 30 seconds idle. The in-memory connectedSites map
-        // does not, and the sign and transaction tests below all require the
-        // origin to still be authorized.
+        // Remembered, because the sign and transaction tests below all
+        // require the origin to still be authorized.
         await popup.check("#approve-remember");
         await clickAndClose(popup, "#btn-approve");
 

tests/e2e/slowApproval.js

@@ -0,0 +1,549 @@
+// A transaction approval and a signature approval the user leaves open for
+// seven minutes, their windows minimized, are still answered, and the site
+// receives both results (https://git.eeqj.de/sneak/AutistMask/issues/540).
+//
+// Both approvals, and the site's requests waiting on them, live only in the
+// background worker's memory. With nothing else going on, Chrome stopped that
+// worker about six minutes after the site's request, while the window was
+// still open, and the user's answer then reached nobody. While an approval is
+// pending, the worker now makes an extension call every 20 seconds, which
+// keeps it running (addPendingApproval() in src/background/index.js). The
+// windows are minimized for the wait because
+// Chrome slows a hidden page's timers to once a minute after a few minutes,
+// so anything the window itself did to keep the worker running would fail
+// here.
+//
+// A separate program from run.js, and not driven by Playwright: Playwright
+// keeps DevTools attached to the background worker, and Chrome never stops a
+// worker DevTools is attached to, so in run.js the worker outlives any wait
+// and a wait there proves nothing. This program starts Chromium itself and
+// speaks the DevTools protocol over the pipe Chromium opens for it
+// (--remote-debugging-pipe), attaching to pages only, never to the worker.
+// Before the approvals are raised it watches the worker stop on its own, so a
+// run in which something else keeps the worker running cannot pass.
+//
+// The site is connected without "Remember", and once the worker has stopped
+// the program requires the site still to be told the address: such a
+// connection used to be held in the worker's memory and ended with it
+// (https://git.eeqj.de/sneak/AutistMask/issues/526).
+//
+// The dApp page and the stub node are the loopback ones the Firefox suite also
+// uses (tests/e2e/dapp.js). The site is connected and the node chosen
+// through the extension's own screens, so nothing is written to its storage
+// from outside.
+//
+// Run through script/test-e2e, which builds the extension and the pinned
+// container.
+//
+//   node tests/e2e/slowApproval.js
+
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const { chromium } = require("playwright-core");
+const {
+    Transaction,
+    getAddress,
+    getBytes,
+    hexlify,
+    parseEther,
+    toQuantity,
+    toUtf8Bytes,
+    verifyMessage,
+} = require("ethers");
+
+const { PASSWORD } = require("./harness");
+const { STUB_COUNTERPARTY } = require("./network");
+const { startDappServer } = require("./dapp");
+
+const DIST_CHROME = path.resolve(__dirname, "..", "..", "dist", "chrome");
+
+// Chrome stopped the worker six minutes after the site's request when nothing
+// kept it running, so the approvals are left open for longer than that.
+const APPROVAL_WAIT_MS = 7 * 60 * 1000;
+
+// With nothing pending, Chrome stops the worker 30 seconds after its last
+// event; this is how long the program waits to see that.
+const IDLE_STOP_TIMEOUT_MS = 90000;
+
+const SIGN_HEX = hexlify(toUtf8Bytes("AutistMask e2e: a slow signature"));
+
+const checks = [];
+let failed = 0;
+
+function check(name, cond, detail) {
+    checks.push(name);
+    if (cond) {
+        console.log("ok " + checks.length + " - " + name);
+    } else {
+        failed += 1;
+        console.log("not ok " + checks.length + " - " + name);
+        if (detail) console.log("  " + detail);
+    }
+}
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Poll `probe` until it returns something truthy, and return that.
+async function until(what, probe, timeout = 30000) {
+    const deadline = Date.now() + timeout;
+    for (;;) {
+        const value = await probe().catch(() => null);
+        if (value) return value;
+        if (Date.now() > deadline) {
+            throw new Error(
+                "gave up after " + timeout + "ms waiting for " + what,
+            );
+        }
+        await sleep(250);
+    }
+}
+
+// The DevTools protocol over Chromium's pipe: commands go to its fd 3, and
+// replies and events come back on its fd 4, each one JSON message ended by a
+// NUL byte. Events are not used and are dropped. Returns send(method, params,
+// sessionId), which resolves with the command's result.
+function devtools(browser) {
+    const waiting = new Map();
+    let nextId = 1;
+    let pending = "";
+    const replies = browser.stdio[4];
+    replies.setEncoding("utf8");
+    replies.on("data", (chunk) => {
+        pending += chunk;
+        let end;
+        while ((end = pending.indexOf("\0")) !== -1) {
+            const message = JSON.parse(pending.slice(0, end));
+            pending = pending.slice(end + 1);
+            const caller = waiting.get(message.id);
+            if (!caller) continue;
+            waiting.delete(message.id);
+            if (message.error) {
+                caller.reject(
+                    new Error(caller.method + ": " + message.error.message),
+                );
+            } else {
+                caller.resolve(message.result);
+            }
+        }
+    });
+    replies.on("close", () => {
+        for (const caller of waiting.values()) {
+            caller.reject(new Error("the browser exited"));
+        }
+        waiting.clear();
+    });
+    return (method, params = {}, sessionId) =>
+        new Promise((resolve, reject) => {
+            const id = nextId++;
+            waiting.set(id, { method, resolve, reject });
+            browser.stdio[3].write(
+                JSON.stringify({ id, method, params, sessionId }) + "\0",
+            );
+        });
+}
+
+// Attach to a page and return a function that evaluates an expression in it,
+// awaiting a promise it returns, and resolves with the value.
+async function attach(send, targetId) {
+    const { sessionId } = await send("Target.attachToTarget", {
+        targetId,
+        flatten: true,
+    });
+    return async (expression) => {
+        const r = await send(
+            "Runtime.evaluate",
+            { expression, awaitPromise: true, returnByValue: true },
+            sessionId,
+        );
+        if (r.exceptionDetails) {
+            throw new Error(
+                "evaluating " +
+                    expression.slice(0, 80) +
+                    " threw: " +
+                    JSON.stringify(r.exceptionDetails.exception || {}),
+            );
+        }
+        return r.result.value;
+    };
+}
+
+// Whether the page has loaded and shows the element with this id: the
+// `hidden` class showView() keeps on every other view is on neither it nor
+// anything around it.
+function shows(id) {
+    return (
+        "document.readyState === 'complete' &&" +
+        " !!document.getElementById(" +
+        JSON.stringify(id) +
+        ") && !document.getElementById(" +
+        JSON.stringify(id) +
+        ").closest('.hidden')"
+    );
+}
+
+// Set an input's value and fire the input event typing would fire.
+function typeInto(id, value) {
+    return (
+        "(() => { const el = document.getElementById(" +
+        JSON.stringify(id) +
+        "); el.value = " +
+        JSON.stringify(value) +
+        "; el.dispatchEvent(new Event('input', { bubbles: true })); })()"
+    );
+}
+
+function click(id) {
+    return "document.getElementById(" + JSON.stringify(id) + ").click()";
+}
+
+// The outcome of a request the dApp page started with __dapp.start(), or
+// {settled: "pending"} if it has not settled within `timeout`.
+function settled(key, timeout = 30000) {
+    return (
+        "Promise.race([window.__dapp.settle(" +
+        JSON.stringify(key) +
+        "), new Promise((r) => setTimeout(() => r({ settled: 'pending' }), " +
+        timeout +
+        "))])"
+    );
+}
+
+async function main() {
+    if (!fs.existsSync(path.join(DIST_CHROME, "manifest.json"))) {
+        console.error(
+            "slowApproval: no unpacked build at " +
+                DIST_CHROME +
+                " — run make build first",
+        );
+        process.exitCode = 1;
+        return;
+    }
+
+    const node = await startDappServer();
+    const profile = fs.mkdtempSync(
+        path.join(os.tmpdir(), "autistmask-slow-approval-"),
+    );
+    const browser = spawn(
+        chromium.executablePath(),
+        [
+            "--headless",
+            // The container runs unprivileged, as in harness.js.
+            "--no-sandbox",
+            "--remote-debugging-pipe",
+            "--user-data-dir=" + profile,
+            "--disable-extensions-except=" + DIST_CHROME,
+            "--load-extension=" + DIST_CHROME,
+            // Nothing but the loopback dApp page and stub node can be reached.
+            "--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE 127.0.0.1",
+            "about:blank",
+        ],
+        { stdio: ["ignore", "ignore", "ignore", "pipe", "pipe"] },
+    );
+
+    try {
+        const send = devtools(browser);
+        const targets = async () =>
+            (await send("Target.getTargets")).targetInfos;
+
+        const worker = await until("the background worker", async () =>
+            (await targets()).find(
+                (t) =>
+                    t.type === "service_worker" &&
+                    t.url.startsWith("chrome-extension://"),
+            ),
+        );
+        // The extension id is the host of the worker's URL, as in harness.js.
+        const popupUrl =
+            "chrome-extension://" +
+            new URL(worker.url).host +
+            "/src/popup/index.html";
+        const workerRunning = async () =>
+            (await targets()).some((t) => t.url === worker.url);
+        const openPage = async (url) => {
+            const { targetId } = await send("Target.createTarget", { url });
+            return { targetId, evaluate: await attach(send, targetId) };
+        };
+        const approvalPages = async () =>
+            (await targets()).filter(
+                (t) => t.type === "page" && t.url.includes("?approval="),
+            );
+
+        // A wallet, through the popup's own screens, and the stub node as its
+        // RPC endpoint, through Settings.
+        const popup = await openPage(popupUrl);
+        await until("the welcome screen", () =>
+            popup.evaluate(shows("view-welcome")),
+        );
+        await popup.evaluate(click("btn-welcome-add"));
+        await until("the add wallet screen", () =>
+            popup.evaluate(shows("view-add-wallet")),
+        );
+        await popup.evaluate(click("btn-generate-phrase"));
+        await until("a generated recovery phrase", () =>
+            popup.evaluate(
+                "document.getElementById('wallet-mnemonic').value.trim()" +
+                    ".split(/\\s+/).length >= 12",
+            ),
+        );
+        await popup.evaluate(typeInto("add-wallet-password", PASSWORD));
+        await popup.evaluate(typeInto("add-wallet-password-confirm", PASSWORD));
+        await popup.evaluate(click("btn-add-wallet-confirm"));
+        await until(
+            "the main screen",
+            () => popup.evaluate(shows("view-main")),
+            60000,
+        );
+        await popup.evaluate(click("btn-settings"));
+        await until("the settings screen", () =>
+            popup.evaluate(shows("view-settings")),
+        );
+        await popup.evaluate(typeInto("settings-rpc", node.rpcUrl));
+        await popup.evaluate(click("btn-save-rpc"));
+        await until("the stub node saved as the RPC endpoint", () =>
+            popup.evaluate(
+                "new Promise((resolve) => chrome.storage.local.get(" +
+                    "'autistmask', (r) => resolve(r.autistmask.rpcUrl === " +
+                    JSON.stringify(node.rpcUrl) +
+                    ")))",
+            ),
+        );
+        await send("Target.closeTarget", { targetId: popup.targetId });
+
+        // The site, connected through the real prompt without "Remember", so
+        // the connection is one that has to outlive the worker stopping below.
+        const dapp = await openPage(node.url);
+        await until("the injected provider", () =>
+            dapp.evaluate("!!window.ethereum && !!window.__dapp"),
+        );
+        await dapp.evaluate(
+            "window.__dapp.start('accounts', 'eth_requestAccounts', [])",
+        );
+        const prompt = await until(
+            "the connection prompt",
+            async () => (await approvalPages())[0],
+        );
+        const inPrompt = await attach(send, prompt.targetId);
+        await until("the connection prompt's screen", () =>
+            inPrompt(shows("view-approve-site")),
+        );
+        await inPrompt(
+            "document.getElementById('approve-remember').checked = false",
+        );
+        // The prompt closes itself on the click.
+        await inPrompt(click("btn-approve")).catch(() => {});
+        const accounts = await dapp.evaluate(settled("accounts"));
+        if (accounts.settled !== "resolved") {
+            throw new Error(
+                "the site could not be connected: " + JSON.stringify(accounts),
+            );
+        }
+        const address = getAddress(accounts.result[0]);
+        console.log("# address " + address + ", site " + node.origin);
+
+        // The control: with nothing pending, the worker stops on its own.
+        // Were something else keeping it running, the wait below would
+        // prove nothing.
+        const idleStart = Date.now();
+        const stoppedWhenIdle = await until(
+            "the idle worker to stop",
+            async () => !(await workerRunning()),
+            IDLE_STOP_TIMEOUT_MS,
+        ).catch(() => false);
+        check(
+            "with nothing pending, Chrome stops the background worker on its own",
+            stoppedWhenIdle,
+            "the worker was still running " +
+                IDLE_STOP_TIMEOUT_MS / 1000 +
+                "s after its last event, so something other than the " +
+                "approval windows is keeping it running",
+        );
+        console.log(
+            "# idle worker stopped after " +
+                Math.round((Date.now() - idleStart) / 1000) +
+                "s",
+        );
+
+        // The site's request starts the worker again, and the new worker still
+        // has the connection allowed without "Remember"
+        // (https://git.eeqj.de/sneak/AutistMask/issues/526).
+        const stillConnected = await dapp.evaluate(
+            "window.ethereum.request({ method: 'eth_accounts' })",
+        );
+        check(
+            "a site allowed without Remember is still connected after the worker stopped",
+            Array.isArray(stillConnected) &&
+                stillConnected.length === 1 &&
+                getAddress(stillConnected[0]) === address,
+            "eth_accounts answered " + JSON.stringify(stillConnected),
+        );
+
+        // A transaction approval and a signature approval, both open at once.
+        await dapp.evaluate(
+            "window.__dapp.start('tx', 'eth_sendTransaction', [" +
+                JSON.stringify({
+                    from: address,
+                    to: STUB_COUNTERPARTY,
+                    value: toQuantity(parseEther("0.01")),
+                }) +
+                "])",
+        );
+        await until("the transaction approval window", async () =>
+            (await approvalPages()).length === 1 ? true : null,
+        );
+        await dapp.evaluate(
+            "window.__dapp.start('sign', 'personal_sign', [" +
+                JSON.stringify(SIGN_HEX) +
+                ", " +
+                JSON.stringify(address) +
+                "])",
+        );
+        const windows = await until("both approval windows", async () => {
+            const pages = await approvalPages();
+            return pages.length === 2 ? pages : null;
+        });
+        let txWindow = null;
+        let signWindow = null;
+        const windowIds = [];
+        for (const page of windows) {
+            const evaluate = await attach(send, page.targetId);
+            const view = await until("an approval screen", () =>
+                evaluate(
+                    "(" +
+                        shows("view-approve-tx") +
+                        ") ? 'tx' : (" +
+                        shows("view-approve-sign") +
+                        ") ? 'sign' : null",
+                ),
+            );
+            if (view === "tx") txWindow = evaluate;
+            if (view === "sign") signWindow = evaluate;
+            const { windowId } = await send("Browser.getWindowForTarget", {
+                targetId: page.targetId,
+            });
+            windowIds.push(windowId);
+        }
+        if (!txWindow || !signWindow) {
+            throw new Error("the two windows are not one of each kind");
+        }
+        const setWindowState = (windowState) =>
+            Promise.all(
+                windowIds.map((windowId) =>
+                    send("Browser.setWindowBounds", {
+                        windowId,
+                        bounds: { windowState },
+                    }),
+                ),
+            );
+
+        // The user minimizes both windows while deciding.
+        await setWindowState("minimized");
+        const bothHidden = await until(
+            "both approval pages hidden",
+            async () =>
+                (await txWindow("document.visibilityState")) === "hidden" &&
+                (await signWindow("document.visibilityState")) === "hidden",
+        ).catch(() => false);
+        check(
+            "both approval windows are minimized, and their pages are hidden",
+            bothHidden,
+            "a page still reports itself visible, so the wait below would " +
+                "not show what happens to a minimized approval",
+        );
+
+        // The user takes seven minutes. The worker is checked every two
+        // seconds, and the wait ends early if Chrome stops it.
+        const opened = Date.now();
+        let stoppedAfter = null;
+        while (Date.now() - opened < APPROVAL_WAIT_MS) {
+            if (!(await workerRunning())) {
+                stoppedAfter = Math.round((Date.now() - opened) / 1000);
+                break;
+            }
+            await sleep(2000);
+        }
+        check(
+            "the background worker keeps running while both approvals wait in minimized windows",
+            stoppedAfter === null,
+            "Chrome stopped the worker " +
+                stoppedAfter +
+                "s after the approvals opened",
+        );
+
+        // Back on screen to be answered.
+        await setWindowState("normal");
+        await txWindow(typeInto("approve-tx-password", PASSWORD));
+        await txWindow(click("btn-approve-tx"));
+        await signWindow(typeInto("approve-sign-password", PASSWORD));
+        // The window closes itself once the signature is handed over.
+        await signWindow(click("btn-approve-sign")).catch(() => {});
+
+        const tx = await dapp.evaluate(settled("tx"));
+        const broadcast = node.broadcast.map((raw) => Transaction.from(raw));
+        check(
+            "the transaction approved after seven minutes reaches the site",
+            tx.settled === "resolved" &&
+                broadcast.length === 1 &&
+                tx.result === broadcast[0].hash &&
+                getAddress(broadcast[0].from) === address,
+            "the page got " +
+                JSON.stringify(tx) +
+                " and the node received " +
+                broadcast.length +
+                " transaction(s)",
+        );
+
+        const sign = await dapp.evaluate(settled("sign"));
+        check(
+            "the signature approved after seven minutes reaches the site",
+            sign.settled === "resolved" &&
+                getAddress(verifyMessage(getBytes(SIGN_HEX), sign.result)) ===
+                    address,
+            "the page got " + JSON.stringify(sign),
+        );
+    } catch (e) {
+        failed += 1;
+        console.log("# ERROR: " + (e && e.stack ? e.stack : e));
+    } finally {
+        if (browser.exitCode === null && browser.signalCode === null) {
+            const exited = new Promise((resolve) =>
+                browser.once("exit", resolve),
+            );
+            browser.kill();
+            await exited;
+        }
+        await node.close();
+        // Chromium's helper processes can still be writing to the profile
+        // for a moment after the browser process itself has exited.
+        fs.rmSync(profile, { recursive: true, force: true, maxRetries: 5 });
+    }
+
+    console.log("1.." + checks.length);
+    if (checks.length === 0) {
+        console.log("# FAILED: this program asserted nothing");
+        process.exitCode = 1;
+        return;
+    }
+    console.log(
+        "# " +
+            (checks.length - failed) +
+            "/" +
+            checks.length +
+            " checks passed",
+    );
+    if (failed > 0) {
+        console.log("# FAILED");
+        process.exitCode = 1;
+    }
+}
+
+main().catch((e) => {
+    console.error("slowApproval: " + (e && e.stack ? e.stack : e));
+    process.exitCode = 1;
+});

tests/ethSign.test.js

@@ -0,0 +1,102 @@
+// The sign screen signs an eth_sign request the way it signs personal_sign: as
+// an EIP-191 personal message over the bytes of the data
+// (https://git.eeqj.de/sneak/AutistMask/issues/409). Booted through the real
+// popup entry point as the approval window. The background's half, which reads
+// the address first and the data second and checks the signature, is tested in
+// tests/backgroundApproval.test.js.
+
+// Mocked so that no password has to be hashed: the stored secret decrypts to
+// the test key below.
+jest.mock("../src/shared/vault", () => ({
+    decryptWithPassword: jest.fn(),
+    encryptWithPassword: jest.fn(),
+}));
+
+const { Wallet, getBytes } = require("ethers");
+const {
+    bootPopup,
+    cleanupPopup,
+    unversionedValidProfile,
+} = require("./support/popupBoot");
+
+// A published test key, never used for real funds.
+const SIGNER_KEY =
+    "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
+const signer = new Wallet(SIGNER_KEY);
+// "Hello AutistMask", as the hex a page sends.
+const MESSAGE = "0x48656c6c6f204175746973744d61736b";
+const ORIGIN = "https://dapp.example";
+
+afterEach(cleanupPopup);
+
+test("the sign screen answers eth_sign with a personal message signature over the data", async () => {
+    const sent = [];
+    const page = await bootPopup(
+        unversionedValidProfile({
+            wallets: [
+                {
+                    type: "key",
+                    name: "Wallet 1",
+                    encryptedSecret: "encrypted-key",
+                    addresses: [
+                        {
+                            address: signer.address,
+                            balance: "0.0000",
+                            tokenBalances: [],
+                        },
+                    ],
+                },
+            ],
+            activeAddress: signer.address,
+            allowedSites: { [signer.address]: [ORIGIN] },
+        }),
+        {
+            search: "?approval=approval-1",
+            runtime: {
+                connect: () => ({ postMessage: () => {} }),
+                // Answered as the background answers: with the eth_sign
+                // approval this window was opened for, and by handing back
+                // the signature the popup sends.
+                sendMessage: (msg, reply) => {
+                    sent.push(msg);
+                    if (msg.type === "AUTISTMASK_GET_APPROVAL") {
+                        reply({
+                            type: "sign",
+                            origin: ORIGIN,
+                            isPhishingDomain: false,
+                            approvedFrom: signer.address,
+                            signParams: {
+                                method: "eth_sign",
+                                message: MESSAGE,
+                                from: signer.address,
+                            },
+                        });
+                    } else if (msg.type === "AUTISTMASK_SIGN_RESPONSE") {
+                        reply({ signature: msg.signature });
+                    } else {
+                        reply(undefined);
+                    }
+                },
+            },
+        },
+    );
+    globalThis.window.close = jest.fn();
+    const { decryptWithPassword } = require("../src/shared/vault");
+    decryptWithPassword.mockResolvedValue(SIGNER_KEY);
+
+    expect(page.visibleViews()).toEqual(["approve-sign"]);
+    page.node("approve-sign-password").value = "any password";
+    await page.click("btn-approve-sign");
+
+    expect(
+        sent.filter((msg) => msg.type === "AUTISTMASK_SIGN_RESPONSE"),
+    ).toEqual([
+        {
+            type: "AUTISTMASK_SIGN_RESPONSE",
+            id: "approval-1",
+            approved: true,
+            signature: await signer.signMessage(getBytes(MESSAGE)),
+        },
+    ]);
+    expect(globalThis.window.close).toHaveBeenCalled();
+});

tests/firstWalletActiveAddress.test.js

@@ -0,0 +1,141 @@
+// 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 adds a wallet
+// through one of the three import tabs and checks which address is active by
+// opening Receive from Home in the same popup.
+
+const { HDNodeWallet, Mnemonic, Wallet } = require("ethers");
+
+const {
+    bootPopup,
+    cleanupPopup,
+    unversionedValidProfile,
+    ADDRESS,
+} = 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;
+
+// Addresses 1 and 2 of PHRASE used, address 0 not: a scan that answers these
+// replaces the wallet's list with one that leaves out its first address.
+const account = HDNodeWallet.fromPhrase(PHRASE, "", "m/44'/60'/0'/0");
+const used = [1, 2].map((index) => ({
+    address: account.deriveChild(index).address,
+    index,
+}));
+
+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,
+    },
+];
+
+// Fills in the open AddWallet screen and presses "Import".
+async function importOn(page, { tab, field, secret }) {
+    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");
+}
+
+afterEach(() => {
+    cleanupPopup();
+});
+
+describe("the first wallet's first address is active right away", () => {
+    test.each(TABS)("added from $tab, Receive opens on it", async (entry) => {
+        const page = await bootPopup(undefined);
+        expect(page.pageErrors).toEqual([]);
+        await page.click("btn-welcome-add");
+        await importOn(page, entry);
+        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(
+            entry.address,
+        );
+    });
+});
+
+describe("a scan that leaves out the first address", () => {
+    // The key tab runs no scan.
+    test.each(TABS.filter((t) => t.tab !== "tab-privkey"))(
+        "added from $tab, the scan's first address is active",
+        async (entry) => {
+            const page = await bootPopup(undefined);
+            const { scanForAddresses } = require("../src/shared/balances");
+            scanForAddresses.mockResolvedValueOnce({
+                addresses: used,
+                nextIndex: 3,
+            });
+            await page.click("btn-welcome-add");
+            await importOn(page, entry);
+
+            expect(page.storage.read("autistmask").activeAddress).toBe(
+                used[0].address,
+            );
+            expect(globalThis.chrome.runtime.sendMessage).toHaveBeenCalledWith({
+                type: "AUTISTMASK_ACTIVE_CHANGED",
+            });
+            await page.click("btn-main-receive");
+            expect(page.node("receive-address-block").dataset.full).toBe(
+                used[0].address,
+            );
+        },
+    );
+});
+
+describe("adding a wallet while an address is active", () => {
+    test.each(TABS)(
+        "added from $tab, the active address is unchanged",
+        async (entry) => {
+            const page = await bootPopup(unversionedValidProfile());
+            expect(page.pageErrors).toEqual([]);
+            // The phrase and xprv scans leave out the new wallet's first
+            // address, which was never active here. The key tab runs no scan.
+            const { scanForAddresses } = require("../src/shared/balances");
+            scanForAddresses.mockResolvedValueOnce({
+                addresses: used,
+                nextIndex: 3,
+            });
+            await page.click("btn-add-wallet-bottom");
+            await importOn(page, entry);
+            expect(page.visibleViews()).toEqual(["main"]);
+
+            expect(page.storage.read("autistmask").activeAddress).toBe(ADDRESS);
+            expect(
+                globalThis.chrome.runtime.sendMessage,
+            ).not.toHaveBeenCalledWith({ type: "AUTISTMASK_ACTIVE_CHANGED" });
+            await page.click("btn-main-receive");
+            expect(page.node("receive-address-block").dataset.full).toBe(
+                ADDRESS,
+            );
+        },
+    );
+});

tests/rpcErrorCodes.test.js

@@ -0,0 +1,282 @@
+// What a page is told when a request fails
+// (https://git.eeqj.de/sneak/AutistMask/issues/533).
+//
+// EIP-1193 gives every rejected request a numeric `code`, and lets it carry
+// `data`. A node's error used to reach the page as its message alone: a
+// reverting eth_call lost code 3 and the revert data a site needs to decode
+// the revert, and a site could not tell that failure from any other.
+//
+// Each request here goes from a page through the real background to a fake
+// node, and what is checked is the answer the background gives the page. The
+// content script relays that answer as it is, and src/content/inpage.js turns
+// its code and data into the error the page catches (tests/inpageErrors.test.js).
+//
+// The background reaches a node two ways, and the fake node answers both:
+// fetch(), which the read-only methods are proxied through, and ethers' own
+// HTTP transport, which a transaction is prepared through.
+
+const { AbiCoder } = require("ethers");
+const { networkById } = require("../src/shared/networks");
+const { makeStorageStub } = require("./support/storageStub");
+
+const ORIGIN = "https://dapp.example";
+const ADDRESS = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+const TOKEN = "0x1111111111111111111111111111111111111111";
+const SEPOLIA = networkById("sepolia");
+
+// Error("bal"), which a token whose transfer() does require(..., "bal")
+// reverts with when the balance is too low.
+const REVERT_DATA =
+    "0x08c379a0" +
+    AbiCoder.defaultAbiCoder().encode(["string"], ["bal"]).slice(2);
+
+// What a node answers for a call that reverts, and for an address that is not
+// one.
+const REVERTED = {
+    code: 3,
+    message: "execution reverted: bal",
+    data: REVERT_DATA,
+};
+const INVALID_ADDRESS = { code: -32602, message: "invalid string length" };
+
+const WITH_ADDRESS = {
+    hasWallet: true,
+    wallets: [
+        {
+            name: "Wallet 1",
+            type: "hd",
+            xpub: "xpub-1",
+            addresses: [
+                { address: ADDRESS, balance: "0.0", tokenBalances: [] },
+            ],
+        },
+    ],
+    activeAddress: ADDRESS,
+    networkId: "sepolia",
+    rpcUrl: SEPOLIA.defaultRpcUrl,
+    blockscoutUrl: SEPOLIA.defaultBlockscoutUrl,
+    allowedSites: { [ADDRESS]: [ORIGIN] },
+    deniedSites: {},
+    trackedTokens: [],
+};
+
+const NO_ADDRESS = {
+    ...WITH_ADDRESS,
+    hasWallet: false,
+    wallets: [],
+    activeAddress: null,
+    allowedSites: {},
+};
+
+const realFetch = globalThis.fetch;
+
+afterEach(() => {
+    delete global.chrome;
+    globalThis.fetch = realFetch;
+});
+
+// The background, over a stored profile, with a node that answers each
+// JSON-RPC method from `node`: a method's entry is the result, or
+// `{ error }` for the error the node answers with. A method not in `node`
+// is answered "method not found", so a test that reaches one fails on it.
+// `node` null is a node that cannot be reached at all.
+function loadBackground(profile, node) {
+    jest.resetModules();
+
+    jest.doMock("../src/shared/phishingDomains", () => ({
+        isPhishingDomain: () => false,
+    }));
+    jest.doMock("../src/shared/alarms", () => ({
+        BALANCE_REFRESH_ALARM: "balance",
+        BALANCE_REFRESH_PERIOD_MINUTES: 1,
+        ensureRecurringAlarms: jest.fn(async () => {}),
+        registerAlarmHandlers: jest.fn(),
+    }));
+
+    function reply({ id, method }) {
+        const entry = node[method];
+        if (entry === undefined) {
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: { code: -32601, message: "method not found: " + method },
+            };
+        }
+        if (entry && entry.error)
+            return { jsonrpc: "2.0", id, error: entry.error };
+        return { jsonrpc: "2.0", id, result: entry };
+    }
+
+    globalThis.fetch = jest.fn(async (url, opts) => {
+        if (!node) throw new TypeError("fetch failed");
+        return { status: 200, json: async () => reply(JSON.parse(opts.body)) };
+    });
+
+    // The ethers the background is about to load: jest.resetModules() above
+    // means it is a fresh copy, not the one this file required at the top.
+    require("ethers").FetchRequest.registerGetUrl(async (req) => {
+        if (!node) throw new Error("connect ECONNREFUSED");
+        const body = JSON.parse(Buffer.from(req.body).toString("utf8"));
+        const answer = Array.isArray(body) ? body.map(reply) : reply(body);
+        return {
+            statusCode: 200,
+            statusMessage: "OK",
+            headers: { "content-type": "application/json" },
+            body: Buffer.from(JSON.stringify(answer)),
+        };
+    });
+
+    let messageListener = null;
+    global.chrome = {
+        storage: makeStorageStub({ autistmask: profile }),
+        runtime: {
+            getURL: (path) => "chrome-extension://autistmask/" + path,
+            onMessage: {
+                addListener: (fn) => {
+                    messageListener = fn;
+                },
+            },
+            onConnect: { addListener: () => {} },
+            lastError: null,
+        },
+        windows: { onRemoved: { addListener: () => {} } },
+        action: { setPopup: () => {} },
+    };
+
+    require("../src/background/index");
+
+    // The answer the page gets to one request.
+    return function request(method, params) {
+        return new Promise((resolve) => {
+            messageListener(
+                { type: "AUTISTMASK_RPC", method, params },
+                { origin: ORIGIN },
+                resolve,
+            );
+        });
+    };
+}
+
+const TRANSFER = {
+    from: ADDRESS,
+    to: TOKEN,
+    // transfer(ADDRESS, 1)
+    data:
+        "0xa9059cbb" +
+        AbiCoder.defaultAbiCoder()
+            .encode(["address", "uint256"], [ADDRESS, 1])
+            .slice(2),
+};
+
+describe("a node's error reaches the page with the node's code and data", () => {
+    test("a reverting eth_call", async () => {
+        const request = loadBackground(WITH_ADDRESS, {
+            eth_call: { error: REVERTED },
+        });
+
+        const answer = await request("eth_call", [TRANSFER, "latest"]);
+
+        expect(answer).toEqual({ error: REVERTED });
+    });
+
+    test("an eth_getBalance for an address that is not one", async () => {
+        const request = loadBackground(WITH_ADDRESS, {
+            eth_getBalance: { error: INVALID_ADDRESS },
+        });
+
+        const answer = await request("eth_getBalance", ["0x1234", "latest"]);
+
+        expect(answer).toEqual({ error: INVALID_ADDRESS });
+    });
+
+    // The wallet's own sentence, with the node's code and revert data, so the
+    // site can decode why its transaction would revert.
+    test("an eth_sendTransaction whose gas estimate reverts", async () => {
+        const request = loadBackground(WITH_ADDRESS, {
+            eth_getTransactionCount: "0x7",
+            eth_estimateGas: { error: REVERTED },
+        });
+
+        const answer = await request("eth_sendTransaction", [TRANSFER]);
+
+        expect(answer).toEqual({
+            error: {
+                code: REVERTED.code,
+                message: expect.stringMatching(
+                    /^The transaction could not be prepared: execution reverted/,
+                ),
+                data: REVERT_DATA,
+            },
+        });
+    });
+});
+
+// One request for each way a request is refused without the node's code: by
+// the wallet itself, or because the node could not be reached.
+describe("no rejected request reaches the page without a numeric code", () => {
+    test.each([
+        [
+            "eth_requestAccounts with no address",
+            NO_ADDRESS,
+            {},
+            "eth_requestAccounts",
+            [],
+            4100,
+        ],
+        [
+            "personal_sign with no address",
+            NO_ADDRESS,
+            {},
+            "personal_sign",
+            ["0x00", ADDRESS],
+            4100,
+        ],
+        [
+            "eth_signTypedData_v4 with no address",
+            NO_ADDRESS,
+            {},
+            "eth_signTypedData_v4",
+            [ADDRESS, "{}"],
+            4100,
+        ],
+        [
+            "eth_sendTransaction with no address",
+            NO_ADDRESS,
+            {},
+            "eth_sendTransaction",
+            [TRANSFER],
+            4100,
+        ],
+        [
+            "eth_sendTransaction with two different gas limits",
+            WITH_ADDRESS,
+            {},
+            "eth_sendTransaction",
+            [{ ...TRANSFER, gas: "0x5208", gasLimit: "0x5209" }],
+            -32602,
+        ],
+        [
+            "eth_call to a node that cannot be reached",
+            WITH_ADDRESS,
+            null,
+            "eth_call",
+            [TRANSFER, "latest"],
+            -32603,
+        ],
+        [
+            "eth_sendTransaction to a node that cannot be reached",
+            WITH_ADDRESS,
+            null,
+            "eth_sendTransaction",
+            [TRANSFER],
+            -32603,
+        ],
+    ])("%s", async (_name, profile, node, method, params, code) => {
+        const request = loadBackground(profile, node);
+
+        const answer = await request(method, params);
+
+        expect(answer.error.code).toBe(code);
+        expect(answer.error.message).toEqual(expect.any(String));
+    });
+});

tests/rpcOrigin.test.js

@@ -8,8 +8,15 @@
 // and a request the browser said nothing about was credited to whatever the
 // page wrote (https://git.eeqj.de/sneak/AutistMask/issues/407).
 //
-// Every sender here lacks sender.origin, as on old Firefox. The connection
-// check on eth_accounts is what shows which site a request was credited to.
+// An origin with no host names no site, so its request is refused
+// (https://git.eeqj.de/sneak/AutistMask/issues/527). The browser reports
+// "null" for a page with an opaque origin, such as one its server sandboxes
+// with a Content-Security-Policy, and Chrome reports "file://" for a local
+// file.
+//
+// Every other sender here lacks sender.origin, as on old Firefox. The
+// connection check on eth_accounts is what shows which site a request was
+// credited to.
 
 const { makeStorageStub } = require("./support/storageStub");
 
@@ -144,3 +151,41 @@ describe("a request the browser does not say the sender of", () => {
         });
     });
 });
+
+describe("a request whose origin has no host", () => {
+    test("from a page with an opaque origin is refused, whatever its URL says", async () => {
+        const accounts = loadBackground();
+
+        const result = await accounts({
+            origin: "null",
+            url: CONNECTED_ORIGIN + "/sandboxed.html",
+            tab: { url: CONNECTED_ORIGIN + "/sandboxed.html" },
+        });
+
+        expect(result).toEqual({
+            error: {
+                code: 4100,
+                message:
+                    "The wallet could not tell which site sent this request.",
+            },
+        });
+    });
+
+    test("from a local file is refused", async () => {
+        const accounts = loadBackground();
+
+        const result = await accounts({
+            origin: "file://",
+            url: "file:///home/user/page.html",
+            tab: { url: "file:///home/user/page.html" },
+        });
+
+        expect(result).toEqual({
+            error: {
+                code: 4100,
+                message:
+                    "The wallet could not tell which site sent this request.",
+            },
+        });
+    });
+});

tests/sendAmountRule.test.js

@@ -0,0 +1,213 @@
+// The Send screen refuses every amount the confirmation screen would refuse,
+// by the same check (https://git.eeqj.de/sneak/AutistMask/issues/532).
+//
+// Send used to accept anything parseFloat() read as above zero, so "1e-3",
+// "1abc" and an amount with more decimal places than the token has went on to
+// a confirmation screen that then refused them. Both screens now call
+// isValidAmount() in src/shared/txValidation.js.
+//
+// Driven through the real Send review handler and the real confirmation
+// screen, with only the node and the DOM stubbed.
+
+"use strict";
+
+jest.mock("../src/shared/log", () => ({
+    log: {
+        debugf: () => {},
+        infof: () => {},
+        warnf: () => {},
+        errorf: () => {},
+    },
+    debugFetch: jest.fn(),
+    setRuntimeDebug: () => {},
+    isDebug: () => false,
+}));
+
+// What the confirmation screen asks the node for.
+const mockProvider = {
+    getFeeData: async () => ({
+        maxFeePerGas: 2000000000n,
+        gasPrice: 1000000000n,
+    }),
+    estimateGas: async () => 21000n,
+    getCode: async () => "0x",
+    getTransactionCount: async () => 1,
+    getBalance: async () => 0n,
+};
+
+jest.mock("../src/shared/balances", () => {
+    const actual = jest.requireActual("../src/shared/balances");
+    return { ...actual, getProvider: () => mockProvider };
+});
+
+// The confirmation screen's Etherscan label lookup fails, as it does offline.
+global.fetch = jest.fn(() => {
+    throw new Error("tests must not perform network requests");
+});
+
+const { makeStorageStub } = require("./support/storageStub");
+global.chrome = { storage: makeStorageStub(), runtime: { sendMessage() {} } };
+
+// A stub DOM: every id resolves to a recording element.
+const elements = new Map();
+
+function makeEl(id) {
+    const handlers = new Map();
+    return {
+        id,
+        textContent: "",
+        innerHTML: "",
+        value: "",
+        disabled: false,
+        style: {},
+        dataset: {},
+        classList: {
+            add() {},
+            remove() {},
+            toggle() {},
+            contains: () => false,
+        },
+        handlers,
+        addEventListener(name, fn) {
+            handlers.set(name, fn);
+        },
+        appendChild(child) {
+            return child;
+        },
+        querySelectorAll: () => [],
+        querySelector: () => null,
+        remove() {},
+        focus() {},
+    };
+}
+
+global.document = {
+    getElementById(id) {
+        if (!elements.has(id)) elements.set(id, makeEl(id));
+        return elements.get(id);
+    },
+    createElement: (tag) => makeEl(tag),
+    body: { prepend() {}, appendChild() {} },
+    addEventListener() {},
+};
+global.navigator = { clipboard: { writeText() {} } };
+
+const { state } = require("../src/shared/state");
+const send = require("../src/popup/views/send");
+const confirmTx = require("../src/popup/views/confirmTx");
+
+const HOLDER = "0x" + "a".repeat(40);
+const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
+// A token with 6 decimal places, as USDC has.
+const TOKEN = "0x" + "d".repeat(40);
+const TOKEN_BY_SYMBOL = { ETH: "ETH", TOK: TOKEN };
+
+function el(id) {
+    return global.document.getElementById(id);
+}
+
+// Press Review on the Send screen with `amount` entered, for a send of `token`
+// ("ETH" or TOKEN), and return what it handed the confirmation screen, or null
+// when it handed nothing over.
+async function review(amount, token) {
+    let handed = null;
+    send.init({ showConfirmTx: (info) => (handed = info) });
+    state.selectedToken = token;
+    el("send-to").value = RECIPIENT;
+    el("send-amount").value = amount;
+    await el("btn-send-review").handlers.get("click")();
+    return handed;
+}
+
+// Show the confirmation screen for the send Review hands over for 0.5, with
+// `amount` in its place, and let its fee estimate settle.
+async function confirm(amount, token) {
+    const txInfo = await review("0.5", token);
+    confirmTx.show({ ...txInfo, amount });
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
+}
+
+beforeEach(() => {
+    elements.clear();
+    state.wallets = [
+        {
+            name: "Wallet 1",
+            addresses: [
+                {
+                    address: HOLDER,
+                    balance: "1.0",
+                    tokenBalances: [
+                        {
+                            address: TOKEN,
+                            name: "Token",
+                            symbol: "TOK",
+                            decimals: 6,
+                            balance: "250.0",
+                            holders: 50000,
+                        },
+                    ],
+                },
+            ],
+        },
+    ];
+    state.selectedWallet = 0;
+    state.selectedAddress = 0;
+    state.trackedTokens = [
+        { address: TOKEN, symbol: "TOK", name: "Token", decimals: 6 },
+    ];
+    state.fraudContracts = [];
+    state.selectedToken = null;
+    state.currentView = null;
+});
+
+describe.each([
+    ["1e-3", "ETH"],
+    ["1e-3", "TOK"],
+    ["1abc", "ETH"],
+    // 19 decimal places; ETH has 18.
+    ["0.0000000000000000001", "ETH"],
+    // 7 decimal places; the token has 6.
+    ["0.0000001", "TOK"],
+    ["0", "ETH"],
+    ["-1", "ETH"],
+])("%s %s", (amount, symbol) => {
+    const token = TOKEN_BY_SYMBOL[symbol];
+
+    test("Send refuses it with a flash message and opens nothing", async () => {
+        expect(await review(amount, token)).toBe(null);
+        expect(el("flash-msg").textContent).toBe(
+            "Please enter a valid amount.",
+        );
+    });
+
+    test("the confirmation screen refuses it too", async () => {
+        await confirm(amount, token);
+        expect(el("confirm-errors").innerHTML).toContain(
+            "Please enter a valid amount to send.",
+        );
+        expect(el("btn-confirm-send").disabled).toBe(true);
+    });
+});
+
+describe.each([
+    ["0.5", "ETH"],
+    ["0.5", "TOK"],
+    // Exactly the 6 decimal places the token has.
+    ["0.000001", "TOK"],
+    // Only zeros past the token's 6 places, and past ETH's 18.
+    ["1.0000000", "TOK"],
+    ["0.5000000000000000000", "ETH"],
+])("%s %s", (amount, symbol) => {
+    const token = TOKEN_BY_SYMBOL[symbol];
+
+    test("Send hands it to the confirmation screen", async () => {
+        expect((await review(amount, token)).amount).toBe(amount);
+        expect(el("flash-msg").textContent).toBe("");
+    });
+
+    test("the confirmation screen lets it be sent", async () => {
+        await confirm(amount, token);
+        expect(el("confirm-errors").innerHTML).toBe("");
+        expect(el("btn-confirm-send").disabled).toBe(false);
+    });
+});

tests/support/popupBoot.js

@@ -242,6 +242,13 @@ async function settle() {
  *     "?approval=" and an id for the popup opened as an approval window.
  * @param {object} [options.runtime] members of chrome.runtime that replace the
  *     stub's own, for a test that has to answer the background's messages.
+ * @param {object} [options.windows] chrome.windows, for a test of the approval
+ *     window resizing itself.
+ * @param {object} [options.tabs] chrome.tabs, for the same test: the page's
+ *     tab and its zoom.
+ * @param {object} [options.documentElement] members of document.documentElement
+ *     that replace the stub's own: scrollWidth and clientWidth, which are equal
+ *     unless a test says otherwise, so the page does not scroll sideways.
  * @returns {Promise<object>} handles onto the booted page.
  */
 async function bootPopup(stored, options) {
@@ -258,12 +265,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
@@ -277,7 +289,13 @@ async function bootPopup(stored, options) {
         (options && options.storage) ||
         makeStorageStub(stored === undefined ? {} : { autistmask: stored });
     const document = makeDocument(POPUP_HTML);
+    Object.assign(
+        document.documentElement,
+        { scrollWidth: 396, clientWidth: 396 },
+        options && options.documentElement,
+    );
     const reloads = [];
+    const windowListeners = {};
 
     globalThis.chrome = {
         storage: { local: storage.local },
@@ -287,6 +305,8 @@ async function bootPopup(stored, options) {
             onMessage: { addListener: () => {} },
             ...(options && options.runtime),
         },
+        windows: options && options.windows,
+        tabs: options && options.tabs,
     };
     globalThis.document = document;
     globalThis.window = {
@@ -300,7 +320,13 @@ async function bootPopup(stored, options) {
             addEventListener: () => {},
             removeEventListener: () => {},
         }),
-        addEventListener: () => {},
+        // Recorded, as the document's are, so a test that widens the approval
+        // window can call the page's resize listeners.
+        listeners: windowListeners,
+        addEventListener: (name, fn) => {
+            windowListeners[name] = windowListeners[name] || [];
+            windowListeners[name].push(fn);
+        },
     };
     // The ten-second refresh init() starts, and a transaction wait's timers,
     // would outlive the test. So every interval is recorded rather than

tests/support/storageStub.js

@@ -1,4 +1,4 @@
-// A chrome.storage.local stub that behaves like the real one.
+// A chrome.storage stub that behaves like the real one.
 //
 // The real extension storage API is a serialization boundary: `set` writes a
 // structured clone of what it is given, and `get` hands back a structured
@@ -17,13 +17,8 @@
 // So every test that drives real persistence uses this, and nothing rebuilds
 // a storage stub by hand.
 
-// `initial` is the starting contents, keyed as storage is: { autistmask: {...} }.
-// `onOp` runs before each operation, for a test that needs to advance a clock
-// or count round trips.
-function makeStorageStub(initial, onOp) {
-    const store = initial ? structuredClone(initial) : {};
-    const tick = onOp || (() => {});
-
+// One storage area: get, set and remove over its own store, cloning both ways.
+function makeArea(store, tick) {
     const get = jest.fn(async (key) => {
         tick();
         if (key === undefined || key === null) return structuredClone(store);
@@ -49,15 +44,28 @@ function makeStorageStub(initial, onOp) {
         for (const k of Array.isArray(key) ? key : [key]) delete store[k];
     });
 
+    return { get, set, remove };
+}
+
+// `initial` is the starting contents of `storage.local`, keyed as storage is:
+// { autistmask: {...} }. `storage.session` starts empty.
+// `onOp` runs before each operation on either area, for a test that needs to
+// advance a clock or count round trips.
+function makeStorageStub(initial, onOp) {
+    const store = initial ? structuredClone(initial) : {};
+    const tick = onOp || (() => {});
+    const local = makeArea(store, tick);
+
     return {
         // Drop this straight in as chrome.storage.
-        local: { get, set, remove },
-        get,
-        set,
-        remove,
-        // What is stored, cloned on the way out: a test can neither observe a
-        // later write through an object it read nor reach into the store by
-        // mutating one.
+        local,
+        session: makeArea({}, tick),
+        get: local.get,
+        set: local.set,
+        remove: local.remove,
+        // What is stored in `storage.local`, cloned on the way out: a test can
+        // neither observe a later write through an object it read nor reach
+        // into the store by mutating one.
         read: (key) =>
             key === undefined
                 ? structuredClone(store)

tests/swapStatusAmount.test.js

@@ -0,0 +1,342 @@
+// The amount the wait and error screens show for a swap whose amount the
+// decoder did not read (https://git.eeqj.de/sneak/AutistMask/issues/358).
+//
+// A V4 swap action not in the deployed shape is not read, and a V4 exact-out
+// action is read for its currencies only, so the approval screen has no
+// Amount line for either. The wait and error screens then showed the
+// transaction's ETH value as the amount, in the swap's input token when the
+// calldata named one ("0.0000 WETH" for a swap of 1 WETH) and in ETH when it
+// did not ("0.0000 ETH"). They now say the amount could not be decoded. A swap
+// paid in native ETH still shows the transaction's ETH value there: that value
+// is the ETH the swap pays.
+//
+// Driven through the real approval screen, password and Confirm included,
+// against a minimal DOM stub in the shape tests/approvalNonce.test.js uses.
+// The vault is mocked so that no password has to be hashed.
+
+jest.mock("../src/shared/vault", () => ({
+    decryptWithPassword: jest.fn(),
+}));
+
+// The wait screen polls for a receipt, which is there once mockReceipt is set.
+let mockReceipt = null;
+jest.mock("../src/shared/balances", () => ({
+    getProvider: () => ({ getTransactionReceipt: async () => mockReceipt }),
+    refreshBalances: () => {},
+}));
+
+globalThis.chrome = {
+    storage: { local: { get: async () => ({}), set: async () => {} } },
+};
+
+const { AbiCoder, Interface } = require("ethers");
+const { state } = require("../src/shared/state");
+const { decryptWithPassword } = require("../src/shared/vault");
+const approval = require("../src/popup/views/approval");
+const txStatus = require("../src/popup/views/txStatus");
+
+// A well-known test phrase, and its first address.
+const PHRASE = "test test test test test test test test test test test junk";
+const FROM = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+const TX_HASH = "0x" + "4".repeat(64);
+
+const ROUTER = "0x66a9893cc07d91d95644aedd05d03f95e1dba8af";
+const ZERO = "0x0000000000000000000000000000000000000000";
+// Both in the bundled list: WETH at 18 decimals, USDC at 6.
+const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+const ONE_WETH = 1000000000000000000n;
+
+const coder = AbiCoder.defaultAbiCoder();
+const routerIface = new Interface([
+    "function execute(bytes commands, bytes[] inputs, uint256 deadline)",
+]);
+
+// V4 action ids and their parameters, each swapping WETH for USDC.
+const POOL_KEY = "tuple(address,address,uint24,int24,address)";
+const WETH_USDC_POOL = [WETH, USDC, 100, 1, ZERO];
+const SWAP_EXACT_IN_SINGLE = 0x06;
+const SWAP_EXACT_OUT_SINGLE = 0x08;
+const SETTLE = 0x0b;
+const SETTLE_ALL = 0x0c;
+const TAKE = 0x0e;
+const TAKE_ALL = 0x0f;
+
+// The struct V4Router has deployed on mainnet and Sepolia.
+const exactInSingle = coder.encode(
+    [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
+    [[WETH_USDC_POOL, true, ONE_WETH, 990000n, "0x"]],
+);
+// The one v4-periphery `main` has moved to, with a `minHopPriceX36` field.
+const newerExactInSingle = coder.encode(
+    [`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
+    [[WETH_USDC_POOL, true, ONE_WETH, 990000n, 0n, "0x"]],
+);
+// Deployed shape: buys 990000 base units of USDC for at most 1 WETH.
+const exactOutSingle = coder.encode(
+    [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
+    [[WETH_USDC_POOL, true, 990000n, ONE_WETH, "0x"]],
+);
+const settleWeth = coder.encode(
+    ["address", "uint256", "bool"],
+    [WETH, 0n, true],
+);
+const takeUsdc = coder.encode(
+    ["address", "address", "uint256"],
+    [USDC, FROM, 0n],
+);
+const settleAllWeth = coder.encode(["address", "uint256"], [WETH, ONE_WETH]);
+const takeAllUsdc = coder.encode(["address", "uint256"], [USDC, 990000n]);
+
+// The same swaps paid in native ETH, which V4 names as the zero address.
+const ETH_USDC_POOL = [ZERO, USDC, 500, 10, ZERO];
+const ONE_ETH = 1000000000000000000n;
+const ethExactOutSingle = coder.encode(
+    [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
+    [[ETH_USDC_POOL, true, 990000n, ONE_ETH, "0x"]],
+);
+const newerEthExactInSingle = coder.encode(
+    [`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
+    [[ETH_USDC_POOL, true, ONE_ETH, 990000n, 0n, "0x"]],
+);
+// The router pays it from the ETH the transaction sends.
+const settleEth = coder.encode(
+    ["address", "uint256", "bool"],
+    [ZERO, 0n, false],
+);
+
+// execute() with one V4_SWAP step of these actions, given as [id, params].
+function v4SwapData(actions) {
+    const input = coder.encode(
+        ["bytes", "bytes[]"],
+        [new Uint8Array(actions.map((a) => a[0])), actions.map((a) => a[1])],
+    );
+    return routerIface.encodeFunctionData("execute", [
+        "0x10",
+        [input],
+        9999999999n,
+    ]);
+}
+
+function makeElement(id) {
+    const classes = new Set();
+    const el = {
+        id,
+        textContent: "",
+        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"),
+        body: { prepend: () => {} },
+    };
+}
+
+function node(id) {
+    return globalThis.document.getElementById(id);
+}
+
+function click(id) {
+    return Promise.all((node(id).listeners.click || []).map((fn) => fn()));
+}
+
+// Open the approval screen for this calldata, sent to the router with `value`
+// wei (no ETH unless given), and confirm it. The background answers the signed
+// transaction with `response`.
+async function approveSwap(data, response, value = 0n) {
+    globalThis.document = makeDocument();
+    globalThis.window = { location: { search: "" }, close: () => {} };
+    globalThis.chrome.runtime = {
+        connect: () => ({ postMessage: () => {} }),
+        sendMessage: (msg, reply) => {
+            if (!reply) return;
+            if (msg.type !== "AUTISTMASK_GET_APPROVAL") return reply(response);
+            reply({
+                type: "tx",
+                origin: "https://dapp.example",
+                isPhishingDomain: false,
+                approvedFrom: FROM,
+                approvedTx: {
+                    type: 2,
+                    from: FROM,
+                    chainId: "0x1",
+                    nonce: "0x7",
+                    gasLimit: "0x30d40",
+                    maxPriorityFeePerGas: "0x3b9aca00",
+                    maxFeePerGas: "0x77359400",
+                    to: ROUTER,
+                    value: "0x" + value.toString(16),
+                    data,
+                    accessList: [],
+                },
+            });
+        },
+    };
+    state.activeAddress = FROM;
+    state.trackedTokens = [];
+    state.wallets = [
+        {
+            type: "hd",
+            name: "Wallet 1",
+            xpub: "xpub-wallet-1",
+            encryptedSecret: "encrypted-secret-1",
+            nextIndex: 1,
+            addresses: [
+                { address: FROM, index: 0, balance: "0", tokenBalances: [] },
+            ],
+        },
+    ];
+    txStatus.init({ doRefreshAndRender: () => {} });
+    approval.init({});
+    await approval.show(1);
+    decryptWithPassword.mockResolvedValue(PHRASE);
+    node("approve-tx-password").value = "any password";
+    await click("btn-approve-tx");
+}
+
+afterEach(() => {
+    txStatus.endWait();
+    mockReceipt = null;
+});
+
+describe.each([
+    [
+        "a swap action in the deployed shape",
+        [
+            [SWAP_EXACT_IN_SINGLE, exactInSingle],
+            [SETTLE, settleWeth],
+            [TAKE, takeUsdc],
+        ],
+        "1.0000 WETH",
+    ],
+    [
+        "a swap action in the newer shape, with SETTLE naming WETH",
+        [
+            [SWAP_EXACT_IN_SINGLE, newerExactInSingle],
+            [SETTLE, settleWeth],
+            [TAKE, takeUsdc],
+        ],
+        "Unknown (could not be decoded)",
+    ],
+    [
+        "a swap action in the newer shape, with SETTLE_ALL and TAKE_ALL",
+        [
+            [SWAP_EXACT_IN_SINGLE, newerExactInSingle],
+            [SETTLE_ALL, settleAllWeth],
+            [TAKE_ALL, takeAllUsdc],
+        ],
+        "Unknown (could not be decoded)",
+    ],
+    [
+        "an exact-out swap action, which is read for its currencies only",
+        [
+            [SWAP_EXACT_OUT_SINGLE, exactOutSingle],
+            [SETTLE, settleWeth],
+            [TAKE, takeUsdc],
+        ],
+        "Unknown (could not be decoded)",
+    ],
+])("%s", (_name, actions, expected) => {
+    test("the wait screen's amount", async () => {
+        await approveSwap(v4SwapData(actions), { txHash: TX_HASH });
+        expect(node("wait-tx-summary").textContent).toBe(expected);
+    });
+
+    test("the error screen's amount", async () => {
+        await approveSwap(v4SwapData(actions), {
+            error: "The transaction could not be sent.",
+            retryable: false,
+        });
+        expect(node("error-tx-summary").textContent).toBe(expected);
+    });
+
+    // The success screen shows the approval screen's decoded lines in place
+    // of the amount, so the ETH value is not on it either.
+    test("the success screen has no amount line of its own", async () => {
+        await approveSwap(v4SwapData(actions), { txHash: TX_HASH });
+        mockReceipt = { blockNumber: 1 };
+        // A later popup resumes the wait, and the receipt is there.
+        txStatus.restoreWait();
+        for (let i = 0; i < 10; i++) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        const summary = node("success-tx-summary").parentElement;
+        expect(summary.classList.contains("hidden")).toBe(true);
+        expect(node("success-tx-decoded").innerHTML).not.toContain("0.0000");
+    });
+});
+
+// A swap paid in native ETH has a Token In of "ETH (native)" and no Amount
+// line, and sends 1 ETH.
+describe.each([
+    [
+        "an exact-out swap action paid in ETH, in the deployed shape",
+        [
+            [SWAP_EXACT_OUT_SINGLE, ethExactOutSingle],
+            [SETTLE, settleEth],
+            [TAKE, takeUsdc],
+        ],
+    ],
+    [
+        "a swap action in the newer shape paid in ETH, with SETTLE naming ETH",
+        [
+            [SWAP_EXACT_IN_SINGLE, newerEthExactInSingle],
+            [SETTLE, settleEth],
+            [TAKE, takeUsdc],
+        ],
+    ],
+])("%s", (_name, actions) => {
+    test("the wait screen shows the ETH the transaction sends", async () => {
+        await approveSwap(v4SwapData(actions), { txHash: TX_HASH }, ONE_ETH);
+        expect(node("wait-tx-summary").textContent).toBe("1.0000 ETH");
+    });
+
+    test("the error screen shows the ETH the transaction sends", async () => {
+        await approveSwap(
+            v4SwapData(actions),
+            {
+                error: "The transaction could not be sent.",
+                retryable: false,
+            },
+            ONE_ETH,
+        );
+        expect(node("error-tx-summary").textContent).toBe("1.0000 ETH");
+    });
+});

tests/tokenTransferDetail.test.js

@@ -0,0 +1,176 @@
+// The decoded details on the transaction detail screen of a token transfer
+// (https://git.eeqj.de/sneak/AutistMask/issues/515).
+//
+// A history row for a token transfer holds the transfer's recipient as its
+// `to`, not the contract the transaction was sent to. The screen used to decode
+// the transaction's data against that `to`, so its Token line named the
+// recipient, and the amount read "decimals unknown" for a token the wallet
+// tracks. It decodes against the address the explorer reports the transaction
+// was sent to.
+//
+// The row is the one the real history parser makes from the explorer's answer,
+// opened through transactionDetail.show(), which is what a click on the row
+// calls. Driven against a minimal DOM stub in the shape
+// tests/contractCreation.test.js uses.
+
+const { Interface } = require("ethers");
+
+jest.mock("../src/shared/log", () => ({
+    log: {
+        debugf: () => {},
+        infof: () => {},
+        warnf: () => {},
+        errorf: () => {},
+    },
+    debugFetch: async (url) => ({
+        ok: true,
+        json: async () => mockExplorerAnswer(url),
+    }),
+    setRuntimeDebug: () => {},
+    isDebug: () => false,
+}));
+
+globalThis.chrome = {
+    storage: { local: { get: async () => ({}), set: async () => {} } },
+};
+
+const { state } = require("../src/shared/state");
+const { fetchRecentTransactions } = require("../src/shared/transactions");
+const transactionDetail = require("../src/popup/views/transactionDetail");
+
+const EXPLORER = "https://explorer.example/api/v2";
+const HOLDER = "0x0000000000000000000000000000000000000a11";
+const RECIPIENT = "0x711e691962E5c054b78071C789A0C8CE657377aD";
+// A token the wallet tracks and the bundled token list does not name.
+const TOKEN = "0x74de5d4FCbf63E00296fd95d33236B9794016631";
+const TX_HASH =
+    "0x85215772ed26ea8b39c2b3b18779030487efbe0b5fd7e882592b2f62b837be84";
+
+// HOLDER sends 1234.5 of the 6-decimal token to RECIPIENT.
+const TRANSFER_DATA = new Interface([
+    "function transfer(address to, uint256 amount)",
+]).encodeFunctionData("transfer", [RECIPIENT, 1234500000n]);
+
+// The explorer's answers: the transfer in HOLDER's token transfers, and the
+// transaction itself, sent to the token contract.
+function mockExplorerAnswer(url) {
+    if (
+        url ===
+        EXPLORER + "/addresses/" + HOLDER + "/token-transfers?type=ERC-20"
+    ) {
+        return {
+            items: [
+                {
+                    transaction_hash: TX_HASH,
+                    block_number: 100,
+                    timestamp: "2026-10-01T00:00:00Z",
+                    from: { hash: HOLDER },
+                    to: { hash: RECIPIENT },
+                    total: { value: "1234500000", decimals: "6" },
+                    token: {
+                        address_hash: TOKEN,
+                        symbol: "TDOL",
+                        holders_count: "5000",
+                    },
+                },
+            ],
+        };
+    }
+    if (url === EXPLORER + "/transactions/" + TX_HASH) {
+        return { to: { hash: TOKEN }, raw_input: TRANSFER_DATA };
+    }
+    return { items: [] };
+}
+
+function makeElement(id) {
+    const classes = new Set();
+    const el = {
+        id,
+        textContent: "",
+        value: "",
+        innerHTML: "",
+        style: {},
+        dataset: {},
+        classList: {
+            add: (...names) => names.forEach((n) => classes.add(n)),
+            remove: (...names) => names.forEach((n) => classes.delete(n)),
+            contains: (n) => classes.has(n),
+            toggle: () => false,
+        },
+        addEventListener: () => {},
+        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"),
+        body: { prepend: () => {} },
+    };
+}
+
+function node(id) {
+    return globalThis.document.getElementById(id);
+}
+
+// One line of the decoded details: its label and what is drawn under it.
+function decodedLine(label) {
+    return node("tx-detail-calldata-details")
+        .innerHTML.split('<div class="mb-2">')
+        .find((line) =>
+            line.startsWith(`<div class="text-muted">${label}</div>`),
+        );
+}
+
+beforeEach(() => {
+    globalThis.document = makeDocument();
+    globalThis.window = { location: { search: "" } };
+    state.blockscoutUrl = EXPLORER;
+    state.wallets = [
+        {
+            name: "Main",
+            type: "key",
+            addresses: [{ address: HOLDER, balance: "0.0000" }],
+        },
+    ];
+    state.trackedTokens = [{ address: TOKEN, symbol: "TDOL", decimals: 6 }];
+    state.viewData = {};
+    state.viewStack = [];
+    state.currentView = null;
+});
+
+test("a token transfer's decoded details name the token contract and the amount at its scale", async () => {
+    const [row] = await fetchRecentTransactions(HOLDER, EXPLORER, 1);
+    expect(row.to).toBe(RECIPIENT);
+    expect(row.contractAddress).toBe(TOKEN.toLowerCase());
+
+    transactionDetail.show(row);
+    // The decoded details are drawn once the explorer has answered.
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
+
+    expect(node("tx-detail-calldata-action").textContent).toBe(
+        "Token Transfer",
+    );
+    const token = decodedLine("Token");
+    expect(token).toContain('<div class="font-bold">TDOL</div>');
+    expect(token).toContain(TOKEN);
+    expect(token).not.toContain(RECIPIENT);
+    expect(decodedLine("Recipient")).toContain(RECIPIENT);
+    expect(decodedLine("Amount")).toContain(
+        '<div class="font-bold">1234.5000 TDOL</div>',
+    );
+});

tests/transferAmount.test.js

@@ -116,6 +116,12 @@ describe("transferAmountUnits", () => {
         expect(() => transferAmountUnits("0.0000001", 6, 6n)).toThrow();
     });
 
+    test("encodes zeros past the token's scale as the amount typed", () => {
+        // The Send screen accepts "1.0000000" for a 6-place token, so the
+        // transfer must move exactly 1 of it.
+        expect(transferAmountUnits("1.0000000", 6, 6n)).toBe(1000000n);
+    });
+
     test("every refusal is a full sentence", () => {
         const messages = [];
         for (const args of [

tests/txValidation.test.js

@@ -6,6 +6,7 @@ const {
     FEE_UNAVAILABLE,
     feeReserveWei,
     feeEstimateWei,
+    isValidAmount,
     maxEthAmount,
     maxTokenAmount,
     toFixedPoint,
@@ -33,6 +34,49 @@ describe("toFixedPoint", () => {
     });
 });
 
+// The one amount check the Send screen and the confirmation screen share.
+// The screens themselves are driven in tests/sendAmountRule.test.js.
+describe("isValidAmount", () => {
+    test("accepts a number above zero written as digits and a decimal point", () => {
+        expect(isValidAmount("0.5")).toBe(true);
+        expect(isValidAmount("12")).toBe(true);
+        expect(isValidAmount(".5")).toBe(true);
+        expect(isValidAmount("0.000000000000000001")).toBe(true);
+    });
+
+    test("refuses an exponent, trailing text, zero and a negative amount", () => {
+        expect(isValidAmount("1e-3")).toBe(false);
+        expect(isValidAmount("1abc")).toBe(false);
+        expect(isValidAmount("0")).toBe(false);
+        expect(isValidAmount("0.0")).toBe(false);
+        expect(isValidAmount("-1")).toBe(false);
+        expect(isValidAmount("")).toBe(false);
+        expect(isValidAmount(undefined)).toBe(false);
+    });
+
+    test("refuses a digit other than 0 past the token's places", () => {
+        expect(isValidAmount("0.000001", 6)).toBe(true);
+        expect(isValidAmount("0.0000001", 6)).toBe(false);
+        expect(isValidAmount("5", 0)).toBe(true);
+        expect(isValidAmount("0.5", 0)).toBe(false);
+    });
+
+    test("accepts zeros past the token's places, which leave the amount unchanged", () => {
+        expect(isValidAmount("1.0000000", 6)).toBe(true);
+        expect(isValidAmount("5.0", 0)).toBe(true);
+        expect(isValidAmount("1.0000000000000000000")).toBe(true);
+        expect(isValidAmount("0.0000000", 6)).toBe(false);
+    });
+
+    test("holds ETH, a token of unknown places, and any token to 18 places", () => {
+        const nineteen = "0.0000000000000000001";
+        expect(isValidAmount(nineteen)).toBe(false);
+        expect(isValidAmount(nineteen, null)).toBe(false);
+        expect(isValidAmount(nineteen, 24)).toBe(false);
+        expect(isValidAmount("0.000000000000000001", 24)).toBe(true);
+    });
+});
+
 describe("validateTransfer, native ETH", () => {
     const eth = (over) => ({
         isErc20: false,
@@ -134,6 +178,17 @@ describe("validateTransfer, native ETH", () => {
         ).toEqual({ canSend: false, codes: [CODES.AMOUNT_INVALID] });
     });
 
+    test("rejects a zero amount and an exponent", () => {
+        expect(validateTransfer(eth({ amount: "0" }))).toEqual({
+            canSend: false,
+            codes: [CODES.AMOUNT_INVALID],
+        });
+        expect(validateTransfer(eth({ amount: "1e-3" }))).toEqual({
+            canSend: false,
+            codes: [CODES.AMOUNT_INVALID],
+        });
+    });
+
     test("treats a missing balance as zero, not as unlimited", () => {
         const r = validateTransfer(eth({ ethBalance: undefined }));
         expect(r.codes).toEqual([CODES.INSUFFICIENT_ETH]);
@@ -205,6 +260,16 @@ describe("validateTransfer, ERC-20", () => {
         expect(r).toEqual({ canSend: false, codes: [CODES.AMOUNT_INVALID] });
     });
 
+    test("rejects more decimal places than the token has", () => {
+        const r = validateTransfer(
+            erc20({ amount: "0.0000001", tokenDecimals: 6 }),
+        );
+        expect(r).toEqual({ canSend: false, codes: [CODES.AMOUNT_INVALID] });
+        expect(
+            validateTransfer(erc20({ amount: "0.000001", tokenDecimals: 6 })),
+        ).toEqual({ canSend: true, codes: [] });
+    });
+
     test("treats a missing token balance as zero", () => {
         const r = validateTransfer(erc20({ tokenBalance: undefined }));
         expect(r.codes).toEqual([CODES.INSUFFICIENT_TOKEN]);

tests/typedDataPermit.test.js

@@ -28,7 +28,7 @@ globalThis.chrome = {
     storage: { local: { get: async () => ({}), set: async () => {} } },
 };
 
-const { getAddress, MaxUint256 } = require("ethers");
+const { getAddress, MaxUint256, TypedDataEncoder } = require("ethers");
 const { state } = require("../src/shared/state");
 const { decryptWithPassword } = require("../src/shared/vault");
 const approval = require("../src/popup/views/approval");
@@ -233,6 +233,26 @@ function warningOf(data) {
     return html.slice(0, html.indexOf(">Domain<"));
 }
 
+const NOT_SIGNED = ">Not part of the signature<";
+
+// The Message section alone, without the keys listed after it as not part of
+// the signature.
+function messageOf(data) {
+    const html = formatTypedDataHtml(JSON.stringify(data));
+    const end = html.indexOf(NOT_SIGNED);
+    return html.slice(
+        html.indexOf(">Message<"),
+        end === -1 ? html.length : end,
+    );
+}
+
+// The keys listed as not part of the signature, or "" when there are none.
+function notSignedOf(data) {
+    const html = formatTypedDataHtml(JSON.stringify(data));
+    const start = html.indexOf(NOT_SIGNED);
+    return start === -1 ? "" : html.slice(start);
+}
+
 function request(data) {
     return { method: "eth_signTypedData_v4", typedData: JSON.stringify(data) };
 }
@@ -312,7 +332,8 @@ describe("the warning reads only the fields the signed type declares", () => {
     });
 
     // A Permit whose type names its spender `operator`; the page adds a
-    // `spender` key the type does not declare.
+    // `spender` key the type does not declare. The Message section names
+    // only the operator, and the added key is listed apart as not signed.
     test("an added key is not named as the spender", () => {
         const data = {
             ...PERMIT,
@@ -331,6 +352,10 @@ describe("the warning reads only the fields the signed type declares", () => {
         const warning = warningOf(data);
         expect(warning).toContain(WARNING);
         expect(warning).not.toContain(DECOY);
+        expect(messageOf(data)).toContain(SPENDER);
+        expect(messageOf(data)).not.toContain(DECOY);
+        expect(notSignedOf(data)).toContain("spender:");
+        expect(notSignedOf(data)).toContain(DECOY);
     });
 
     // The permit for a Uniswap v3 position NFT: a `Permit` with no amount
@@ -371,6 +396,47 @@ describe("the warning reads only the fields the signed type declares", () => {
     });
 });
 
+// ethers signs only the declared fields at every level of nesting, so an
+// added key inside a struct is not signed either. Such typed data is not
+// refused; the added key is listed apart, with where it sits in the message.
+describe("the Message section shows only the fields that are signed", () => {
+    const NOTE = "This signature only signs you in";
+
+    test("an added key inside a nested struct is listed as not signed", () => {
+        const data = {
+            ...PERMIT_SINGLE,
+            message: {
+                ...PERMIT_SINGLE.message,
+                details: { ...PERMIT_SINGLE.message.details, note: NOTE },
+            },
+        };
+        expect(messageOf(data)).toContain("expiration");
+        expect(messageOf(data)).not.toContain(NOTE);
+        expect(notSignedOf(data)).toContain("details.note:");
+        expect(notSignedOf(data)).toContain(NOTE);
+        expect(typedDataRefusal(request(data))).toBeNull();
+    });
+
+    test("an added key inside a list item is listed with its index", () => {
+        const [first, second] = PERMIT_BATCH.message.details;
+        const data = {
+            ...PERMIT_BATCH,
+            message: {
+                ...PERMIT_BATCH.message,
+                details: [first, { ...second, note: NOTE }],
+            },
+        };
+        expect(messageOf(data)).not.toContain(NOTE);
+        expect(notSignedOf(data)).toContain("details[1].note:");
+        expect(notSignedOf(data)).toContain(NOTE);
+    });
+
+    test("nothing is listed apart when every key is declared", () => {
+        expect(notSignedOf(PERMIT_SINGLE)).toBe("");
+        expect(notSignedOf(LOGIN)).toBe("");
+    });
+});
+
 describe("the primary type shown is the one ethers signs", () => {
     // A drain stated as a sign-in: the page says Login, the types say
     // PermitSingle, and ethers would sign PermitSingle.
@@ -596,3 +662,107 @@ 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/uniswap.test.js

@@ -107,6 +107,7 @@ function encodeV4Swap(actions, params) {
 // V4 inner action IDs, as src/shared/uniswap.js names them.
 const V4_SWAP_EXACT_IN = 0x07;
 const V4_SWAP_EXACT_IN_SINGLE_ID = 0x06;
+const V4_SWAP_EXACT_OUT_SINGLE_ID = 0x08;
 const V4_SETTLE_ID = 0x0b;
 const V4_TAKE_ID = 0x0e;
 const ZERO_ADDR = "0x0000000000000000000000000000000000000000";
@@ -163,6 +164,151 @@ function encodeV4ExactInSingle(currency0, currency1, amountIn, amountOutMin) {
     );
 }
 
+// Helper: V4 ExactOutputSingleParams —
+//   (tuple(address,address,uint24,int24,address) poolKey, bool zeroForOne,
+//    uint128 amountOut, uint128 amountInMaximum, bytes hookData)
+function encodeV4ExactOutSingle(
+    currency0,
+    currency1,
+    amountOut,
+    amountInMaximum,
+) {
+    return coder.encode(
+        [
+            "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
+        ],
+        [
+            [
+                [currency0, currency1, 100, 1, ZERO_ADDR],
+                true, // zeroForOne: in = currency0, out = currency1
+                amountOut,
+                amountInMaximum,
+                "0x",
+            ],
+        ],
+    );
+}
+
+// Each V4 swap action's parameters in two shapes: the struct V4Router has
+// deployed on mainnet and Sepolia, and the one v4-periphery `main` has since
+// moved to, which adds a `minHopPriceX36` field. Each swaps WETH for USDC.
+const POOL_KEY = "tuple(address,address,uint24,int24,address)";
+const PATH_KEY = "tuple(address,uint24,int24,address,bytes)";
+const WETH_USDC_POOL = [WETH_ADDR, USDC_ADDR, 100, 1, ZERO_ADDR];
+const ONE_WETH = 1000000000000000000n;
+const V4_SWAP_ACTION_SHAPES = [
+    {
+        action: "SWAP_EXACT_IN_SINGLE",
+        id: 0x06,
+        deployed: coder.encode(
+            [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
+            [[WETH_USDC_POOL, true, ONE_WETH, 990000n, "0x"]],
+        ),
+        newer: coder.encode(
+            [`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
+            [[WETH_USDC_POOL, true, ONE_WETH, 990000n, 0n, "0x"]],
+        ),
+    },
+    {
+        action: "SWAP_EXACT_IN",
+        id: 0x07,
+        deployed: coder.encode(
+            [`tuple(address,${PATH_KEY}[],uint128,uint128)`],
+            [
+                [
+                    WETH_ADDR,
+                    [[USDC_ADDR, 100, 1, ZERO_ADDR, "0x"]],
+                    ONE_WETH,
+                    990000n,
+                ],
+            ],
+        ),
+        newer: coder.encode(
+            [`tuple(address,${PATH_KEY}[],uint256[],uint128,uint128)`],
+            [
+                [
+                    WETH_ADDR,
+                    [[USDC_ADDR, 100, 1, ZERO_ADDR, "0x"]],
+                    [],
+                    ONE_WETH,
+                    990000n,
+                ],
+            ],
+        ),
+    },
+    {
+        action: "SWAP_EXACT_OUT_SINGLE",
+        id: 0x08,
+        deployed: coder.encode(
+            [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
+            [[WETH_USDC_POOL, true, 990000n, ONE_WETH, "0x"]],
+        ),
+        newer: coder.encode(
+            [`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
+            [[WETH_USDC_POOL, true, 990000n, ONE_WETH, 0n, "0x"]],
+        ),
+    },
+    {
+        action: "SWAP_EXACT_OUT",
+        id: 0x09,
+        deployed: coder.encode(
+            [`tuple(address,${PATH_KEY}[],uint128,uint128)`],
+            [
+                [
+                    USDC_ADDR,
+                    [[WETH_ADDR, 100, 1, ZERO_ADDR, "0x"]],
+                    990000n,
+                    ONE_WETH,
+                ],
+            ],
+        ),
+        newer: coder.encode(
+            [`tuple(address,${PATH_KEY}[],uint256[],uint128,uint128)`],
+            [
+                [
+                    USDC_ADDR,
+                    [[WETH_ADDR, 100, 1, ZERO_ADDR, "0x"]],
+                    [],
+                    990000n,
+                    ONE_WETH,
+                ],
+            ],
+        ),
+    },
+];
+
+// Helper: execute() with one V4_SWAP step holding the swap action, then
+// SETTLE of WETH and TAKE of USDC.
+function v4SwapCalldata(actionId, swapParams) {
+    return buildExecute(
+        "0x10",
+        [
+            encodeV4Swap(new Uint8Array([actionId, V4_SETTLE_ID, V4_TAKE_ID]), [
+                swapParams,
+                encodeV4Settle(WETH_ADDR),
+                encodeV4Take(USDC_ADDR),
+            ]),
+        ],
+        9999999999n,
+    );
+}
+
+// V4 SETTLE_ALL (currency, maxAmount) and TAKE_ALL (currency, minAmount).
+const V4_SETTLE_ALL_ID = 0x0c;
+const V4_TAKE_ALL_ID = 0x0f;
+function encodeV4SettleAll(currency, maxAmount) {
+    return coder.encode(["address", "uint256"], [currency, maxAmount]);
+}
+function encodeV4TakeAll(currency, minAmount) {
+    return coder.encode(["address", "uint256"], [currency, minAmount]);
+}
+
+// V4 CLOSE_CURRENCY (currency), which the decoder does not read.
+const V4_CLOSE_CURRENCY_ID = 0x12;
+function encodeV4CloseCurrency(currency) {
+    return coder.encode(["address"], [currency]);
+}
+
 function detail(result, label) {
     return result.details.find((d) => d.label === label);
 }
@@ -203,9 +349,168 @@ describe("uniswap decoder", () => {
             result.details.find((d) => d.label === "Min. received").value,
         ).toBe("0.0002 ETH");
 
+        // Real mainnet calldata is in the deployed shape, so its V4 step is
+        // not said to be undecoded.
         const steps = result.details.find((d) => d.label === "Steps");
-        expect(steps.value).toContain("Permit2 Permit");
-        expect(steps.value).toContain("V4 Swap");
+        expect(steps.value).toBe("Permit2 Permit → V4 Swap");
+    });
+
+    test.each(V4_SWAP_ACTION_SHAPES)(
+        "a V4 $action in the deployed shape is read",
+        ({ id, deployed }) => {
+            const result = uniswap.decode(
+                v4SwapCalldata(id, deployed),
+                ROUTER_ADDR,
+            );
+            expect(detail(result, "Steps").value).toBe("V4 Swap");
+        },
+    );
+
+    // https://git.eeqj.de/sneak/AutistMask/issues/358 — before it, all four
+    // newer structs decoded as the deployed ones without an error, and the
+    // newer SWAP_EXACT_IN showed the offset of its hop-price array as Amount
+    // ("0.0000000000000004 WETH") and its amountIn as Min. received.
+    test.each(V4_SWAP_ACTION_SHAPES)(
+        "a V4 $action in the newer periphery shape is shown as not decoded",
+        ({ id, newer }) => {
+            const result = uniswap.decode(
+                v4SwapCalldata(id, newer),
+                ROUTER_ADDR,
+            );
+            expect(detail(result, "Amount")).toBeUndefined();
+            expect(detail(result, "Min. received")).toBeUndefined();
+            expect(detail(result, "Steps").value).toBe(
+                "V4 Swap (could not be decoded)",
+            );
+            // SETTLE and TAKE keep their own shape and still name both sides.
+            expect(detail(result, "Token In").address).toBe(WETH_ADDR);
+            expect(detail(result, "Token Out").address).toBe(USDC_ADDR);
+        },
+    );
+
+    // SETTLE_ALL and TAKE_ALL name both sides as SETTLE and TAKE do.
+    test.each(V4_SWAP_ACTION_SHAPES)(
+        "a V4 $action in the newer shape, then SETTLE_ALL and TAKE_ALL, takes both tokens from them",
+        ({ id, newer }) => {
+            const data = buildExecute(
+                "0x10",
+                [
+                    encodeV4Swap(
+                        new Uint8Array([id, V4_SETTLE_ALL_ID, V4_TAKE_ALL_ID]),
+                        [
+                            newer,
+                            encodeV4SettleAll(WETH_ADDR, ONE_WETH),
+                            encodeV4TakeAll(USDC_ADDR, 990000n),
+                        ],
+                    ),
+                ],
+                9999999999n,
+            );
+            const result = uniswap.decode(data, ROUTER_ADDR);
+            expect(detail(result, "Steps").value).toBe(
+                "V4 Swap (could not be decoded)",
+            );
+            expect(detail(result, "Token In").address).toBe(WETH_ADDR);
+            expect(detail(result, "Token Out").address).toBe(USDC_ADDR);
+            expect(detail(result, "Amount")).toBeUndefined();
+            expect(detail(result, "Min. received")).toBeUndefined();
+        },
+    );
+
+    // Only the unread swap action names the currencies here. The token lines
+    // must not say the calldata did not name them.
+    test.each(V4_SWAP_ACTION_SHAPES)(
+        "a V4 step of only a $action in the newer shape says both tokens could not be decoded",
+        ({ id, newer }) => {
+            const data = buildExecute(
+                "0x10",
+                [encodeV4Swap(new Uint8Array([id]), [newer])],
+                9999999999n,
+            );
+            const result = uniswap.decode(data, ROUTER_ADDR);
+            expect(detail(result, "Steps").value).toBe(
+                "V4 Swap (could not be decoded)",
+            );
+            expect(detail(result, "Token In").value).toBe(
+                "Unknown (could not be decoded)",
+            );
+            expect(detail(result, "Token Out").value).toBe(
+                "Unknown (could not be decoded)",
+            );
+        },
+    );
+
+    // The user receives the V4 step's USDC, which only its unread swap
+    // action names. The V3 step's WETH and its Min. received figure were
+    // shown instead.
+    test.each(V4_SWAP_ACTION_SHAPES)(
+        "a V3 step, then a V4 step of only a $action in the newer shape, does not show the V3 step's output",
+        ({ id, newer }) => {
+            const data = buildExecute(
+                solidityPacked(["uint8", "uint8"], [0x00, 0x10]),
+                [
+                    encodeV3SwapExactIn(USER_ADDR, 2000000n, ONE_WETH, [
+                        USDT_ADDR,
+                        WETH_ADDR,
+                    ]),
+                    encodeV4Swap(new Uint8Array([id]), [newer]),
+                ],
+                9999999999n,
+            );
+            const result = uniswap.decode(data, ROUTER_ADDR);
+            expect(result.name).toBe("Uniswap Swap");
+            expect(detail(result, "Amount").value).toBe("2.0000 USDT");
+            expect(detail(result, "Token Out").value).toBe(
+                "Unknown (could not be decoded)",
+            );
+            expect(detail(result, "Min. received")).toBeUndefined();
+        },
+    );
+
+    // The user pays the V4 step's WETH, which only its unread swap action
+    // names. The V3 step's USDC and its amount were shown instead.
+    test.each(V4_SWAP_ACTION_SHAPES)(
+        "a V4 step of only a $action in the newer shape, then a V3 step, does not show the V3 step's input",
+        ({ id, newer }) => {
+            const data = buildExecute(
+                solidityPacked(["uint8", "uint8"], [0x10, 0x00]),
+                [
+                    encodeV4Swap(new Uint8Array([id]), [newer]),
+                    encodeV3SwapExactIn(
+                        USER_ADDR,
+                        990000n,
+                        980000000000000000n,
+                        [USDC_ADDR, DAI_ADDR],
+                    ),
+                ],
+                9999999999n,
+            );
+            const result = uniswap.decode(data, ROUTER_ADDR);
+            expect(result.name).toBe("Uniswap Swap");
+            expect(detail(result, "Token In").value).toBe(
+                "Unknown (could not be decoded)",
+            );
+            expect(detail(result, "Amount")).toBeUndefined();
+            expect(detail(result, "Min. received").value).toBe("0.9800 DAI");
+        },
+    );
+
+    // UNWRAP_WETH makes Token Out ETH when no step set the output side. An
+    // unread swap action's step did set it, to undetermined.
+    test("an UNWRAP_WETH after an unread V4 swap action does not make Token Out ETH", () => {
+        const { id, newer } = V4_SWAP_ACTION_SHAPES[0];
+        const data = buildExecute(
+            solidityPacked(["uint8", "uint8"], [0x10, 0x0c]),
+            [
+                encodeV4Swap(new Uint8Array([id]), [newer]),
+                encodeWrapEth(USER_ADDR, 0n), // UNWRAP_WETH, same encoding
+            ],
+            9999999999n,
+        );
+        const result = uniswap.decode(data, ROUTER_ADDR);
+        expect(detail(result, "Token Out").value).toBe(
+            "Unknown (could not be decoded)",
+        );
     });
 
     test("decodes V2_SWAP_EXACT_IN with known tokens", () => {
@@ -548,9 +853,11 @@ describe("uniswap decoder", () => {
         const result = uniswap.decode(data, ROUTER_ADDR);
         expect(result).not.toBeNull();
 
+        // The V4 swap action's parameters are empty, so that step is said to
+        // be undecoded.
         const steps = result.details.find((d) => d.label === "Steps");
         expect(steps.value).toBe(
-            "Permit2 Permit \u2192 V4 Swap \u2192 Unwrap WETH",
+            "Permit2 Permit \u2192 V4 Swap (could not be decoded) \u2192 Unwrap WETH",
         );
     });
 
@@ -858,6 +1165,419 @@ describe("uniswap decoder", () => {
         expect(detail(result, "Min. received").value).toBe("0.9900 USDC");
     });
 
+    // https://git.eeqj.de/sneak/AutistMask/issues/563 — a V4 step of several
+    // swap actions. The screen showed the first action's output as Token Out.
+    // Every step below pays USDT and receives USDC, so it reads Swap USDT →
+    // USDC whichever kind of swap actions it holds and in whatever order they
+    // are written. Each is tried with three endings: SETTLE_ALL and TAKE_ALL,
+    // SETTLE and TAKE, and CLOSE_CURRENCY for each currency, which leaves the
+    // sides to the swap actions alone.
+    const V4_STEP_ENDINGS = [
+        {
+            ending: "SETTLE_ALL and TAKE_ALL",
+            ids: [V4_SETTLE_ALL_ID, V4_TAKE_ALL_ID],
+            params: [
+                encodeV4SettleAll(USDT_ADDR, 1000000000n),
+                encodeV4TakeAll(USDC_ADDR, 990000000n),
+            ],
+        },
+        {
+            ending: "SETTLE and TAKE",
+            ids: [V4_SETTLE_ID, V4_TAKE_ID],
+            params: [encodeV4Settle(USDT_ADDR), encodeV4Take(USDC_ADDR)],
+        },
+        {
+            ending: "CLOSE_CURRENCY",
+            ids: [
+                V4_CLOSE_CURRENCY_ID,
+                V4_CLOSE_CURRENCY_ID,
+                V4_CLOSE_CURRENCY_ID,
+            ],
+            params: [
+                encodeV4CloseCurrency(USDT_ADDR),
+                encodeV4CloseCurrency(WETH_ADDR),
+                encodeV4CloseCurrency(USDC_ADDR),
+            ],
+        },
+    ];
+    // 1,000 USDT for at least 0.5 WETH
+    const USDT_FOR_WETH_IN = {
+        id: V4_SWAP_EXACT_IN_SINGLE_ID,
+        param: encodeV4ExactInSingle(
+            USDT_ADDR,
+            WETH_ADDR,
+            1000000000n,
+            500000000000000000n,
+        ),
+    };
+    // 0.5 WETH for at least 990 USDC
+    const WETH_FOR_USDC_IN = {
+        id: V4_SWAP_EXACT_IN_SINGLE_ID,
+        param: encodeV4ExactInSingle(
+            WETH_ADDR,
+            USDC_ADDR,
+            500000000000000000n,
+            990000000n,
+        ),
+    };
+    // exactly 0.5 WETH for at most 1,000 USDT
+    const USDT_FOR_WETH_OUT = {
+        id: V4_SWAP_EXACT_OUT_SINGLE_ID,
+        param: encodeV4ExactOutSingle(
+            USDT_ADDR,
+            WETH_ADDR,
+            500000000000000000n,
+            1000000000n,
+        ),
+    };
+    // exactly 990 USDC for at most 0.5 WETH
+    const WETH_FOR_USDC_OUT = {
+        id: V4_SWAP_EXACT_OUT_SINGLE_ID,
+        param: encodeV4ExactOutSingle(
+            WETH_ADDR,
+            USDC_ADDR,
+            990000000n,
+            500000000000000000n,
+        ),
+    };
+    // 400 USDT for at least 396 USDC
+    const USDT_FOR_USDC_IN = {
+        id: V4_SWAP_EXACT_IN_SINGLE_ID,
+        param: encodeV4ExactInSingle(
+            USDT_ADDR,
+            USDC_ADDR,
+            400000000n,
+            396000000n,
+        ),
+    };
+    // 600 USDT through WETH for at least 594 USDC
+    const USDT_FOR_USDC_THROUGH_WETH_IN = {
+        id: V4_SWAP_EXACT_IN,
+        param: encodeV4ExactIn(
+            USDT_ADDR,
+            [WETH_ADDR, USDC_ADDR],
+            600000000n,
+            594000000n,
+        ),
+    };
+    // the open delta of USDT through WETH for at least 594 USDC
+    const USDT_OPEN_DELTA_FOR_USDC_THROUGH_WETH_IN = {
+        id: V4_SWAP_EXACT_IN,
+        param: encodeV4ExactIn(
+            USDT_ADDR,
+            [WETH_ADDR, USDC_ADDR],
+            0n,
+            594000000n,
+        ),
+    };
+    // Amount is the amountIn of the action that spends USDT, or the sum when
+    // several exact-in actions each state one. Min. received is the same for
+    // the actions that buy USDC. The decoder reads no amount from an exact-out
+    // action, and an open delta is not a stated amount.
+    const V4_STEPS = [
+        {
+            step: "USDT for WETH exact-in, then WETH for USDC exact-in",
+            swaps: [USDT_FOR_WETH_IN, WETH_FOR_USDC_IN],
+            amount: "1000.0000 USDT",
+            min: "990.0000 USDC",
+        },
+        {
+            step: "WETH for USDC exact-in, then USDT for WETH exact-in",
+            swaps: [WETH_FOR_USDC_IN, USDT_FOR_WETH_IN],
+            amount: "1000.0000 USDT",
+            min: "990.0000 USDC",
+        },
+        {
+            step: "WETH for USDC exact-out, then USDT for WETH exact-out",
+            swaps: [WETH_FOR_USDC_OUT, USDT_FOR_WETH_OUT],
+            amount: undefined,
+            min: undefined,
+        },
+        {
+            step: "USDT for WETH exact-out, then WETH for USDC exact-out",
+            swaps: [USDT_FOR_WETH_OUT, WETH_FOR_USDC_OUT],
+            amount: undefined,
+            min: undefined,
+        },
+        {
+            step: "USDT for WETH exact-in, then WETH for USDC exact-out",
+            swaps: [USDT_FOR_WETH_IN, WETH_FOR_USDC_OUT],
+            amount: "1000.0000 USDT",
+            min: undefined,
+        },
+        {
+            step: "WETH for USDC exact-out, then USDT for WETH exact-in",
+            swaps: [WETH_FOR_USDC_OUT, USDT_FOR_WETH_IN],
+            amount: "1000.0000 USDT",
+            min: undefined,
+        },
+        {
+            step: "USDT for WETH exact-out, then WETH for USDC exact-in",
+            swaps: [USDT_FOR_WETH_OUT, WETH_FOR_USDC_IN],
+            amount: undefined,
+            min: "990.0000 USDC",
+        },
+        {
+            step: "USDT for USDC, then USDT for USDC through WETH, both exact-in",
+            swaps: [USDT_FOR_USDC_IN, USDT_FOR_USDC_THROUGH_WETH_IN],
+            amount: "1000.0000 USDT",
+            min: "990.0000 USDC",
+        },
+        {
+            step: "USDT for USDC, then the open delta of USDT for USDC through WETH, both exact-in",
+            swaps: [USDT_FOR_USDC_IN, USDT_OPEN_DELTA_FOR_USDC_THROUGH_WETH_IN],
+            amount: undefined,
+            min: "990.0000 USDC",
+        },
+    ];
+    test.each(
+        V4_STEPS.flatMap((step) =>
+            V4_STEP_ENDINGS.map((ending) => ({ ...step, ...ending })),
+        ),
+    )(
+        "a V4 step of $step, then $ending, reads Swap USDT → USDC",
+        ({ swaps, ids, params, amount, min }) => {
+            const data = buildExecute(
+                "0x10",
+                [
+                    encodeV4Swap(
+                        new Uint8Array([...swaps.map((s) => s.id), ...ids]),
+                        [...swaps.map((s) => s.param), ...params],
+                    ),
+                ],
+                9999999999n,
+            );
+
+            const result = uniswap.decode(data, ROUTER_ADDR);
+            expect(result.name).toBe("Swap USDT → USDC");
+            expect(detail(result, "Token In").address).toBe(USDT_ADDR);
+            expect(detail(result, "Token Out").address).toBe(USDC_ADDR);
+            expect(detail(result, "Amount")?.value).toBe(amount);
+            expect(detail(result, "Min. received")?.value).toBe(min);
+        },
+    );
+
+    // A step with a swap action that could not be read is named only by its
+    // SETTLE_ALL, TAKE_ALL, SETTLE and TAKE, and states no figure: its readable
+    // USDT for WETH action names neither side. The unread action is
+    // V4_SWAP_ACTION_SHAPES[0].newer, WETH for USDC exact-in in the newer
+    // shape.
+    test.each([
+        {
+            ...V4_STEP_ENDINGS[0],
+            tokenIn: `USDT (${USDT_ADDR})`,
+            tokenOut: `USDC (${USDC_ADDR})`,
+        },
+        {
+            ...V4_STEP_ENDINGS[1],
+            tokenIn: `USDT (${USDT_ADDR})`,
+            tokenOut: `USDC (${USDC_ADDR})`,
+        },
+        {
+            ...V4_STEP_ENDINGS[2],
+            tokenIn: "Unknown (could not be decoded)",
+            tokenOut: "Unknown (could not be decoded)",
+        },
+    ])(
+        "a V4 step of a readable swap action and an unread one, then $ending, shows no figure",
+        ({ ids, params, tokenIn, tokenOut }) => {
+            const data = buildExecute(
+                "0x10",
+                [
+                    encodeV4Swap(
+                        new Uint8Array([
+                            USDT_FOR_WETH_IN.id,
+                            V4_SWAP_ACTION_SHAPES[0].id,
+                            ...ids,
+                        ]),
+                        [
+                            USDT_FOR_WETH_IN.param,
+                            V4_SWAP_ACTION_SHAPES[0].newer,
+                            ...params,
+                        ],
+                    ),
+                ],
+                9999999999n,
+            );
+
+            const result = uniswap.decode(data, ROUTER_ADDR);
+            expect(detail(result, "Steps").value).toBe(
+                "V4 Swap (could not be decoded)",
+            );
+            expect(detail(result, "Token In").value).toBe(tokenIn);
+            expect(detail(result, "Token Out").value).toBe(tokenOut);
+            expect(detail(result, "Amount")).toBeUndefined();
+            expect(detail(result, "Min. received")).toBeUndefined();
+        },
+    );
+
+    // A V4 step that spends WETH on USDC and on DAI. Its swap actions buy two
+    // currencies that none of them spends, and CLOSE_CURRENCY, which the
+    // decoder does not read, names no side, so its output side is unknown.
+    const WETH_FOR_USDC_AND_DAI = encodeV4Swap(
+        new Uint8Array([
+            V4_SWAP_EXACT_IN_SINGLE_ID,
+            V4_SWAP_EXACT_IN_SINGLE_ID,
+            V4_CLOSE_CURRENCY_ID,
+            V4_CLOSE_CURRENCY_ID,
+            V4_CLOSE_CURRENCY_ID,
+        ]),
+        [
+            // 0.25 WETH for at least 495 USDC
+            encodeV4ExactInSingle(
+                WETH_ADDR,
+                USDC_ADDR,
+                250000000000000000n,
+                495000000n,
+            ),
+            // 0.25 WETH for at least 495 DAI
+            encodeV4ExactInSingle(
+                WETH_ADDR,
+                DAI_ADDR,
+                250000000000000000n,
+                495000000000000000000n,
+            ),
+            encodeV4CloseCurrency(WETH_ADDR),
+            encodeV4CloseCurrency(USDC_ADDR),
+            encodeV4CloseCurrency(DAI_ADDR),
+        ],
+    );
+
+    // The user ends with USDC and DAI, not the V3 step's WETH. That WETH and
+    // the V3 step's Min. received figure were shown instead.
+    test("a V3 step, then a V4 step whose swap actions buy two currencies, does not show the V3 step's output", () => {
+        const data = buildExecute(
+            solidityPacked(["uint8", "uint8"], [0x00, 0x10]),
+            [
+                encodeV3SwapExactIn(
+                    USER_ADDR,
+                    1000000000n,
+                    500000000000000000n,
+                    [USDT_ADDR, WETH_ADDR],
+                ),
+                WETH_FOR_USDC_AND_DAI,
+            ],
+            9999999999n,
+        );
+        const result = uniswap.decode(data, ROUTER_ADDR);
+        expect(result.name).toBe("Uniswap Swap");
+        expect(detail(result, "Token In").address).toBe(
+            USDT_ADDR.toLowerCase(),
+        );
+        expect(detail(result, "Amount").value).toBe("1000.0000 USDT");
+        expect(detail(result, "Token Out").value).toBe(
+            "Unknown (not named in the calldata)",
+        );
+        expect(detail(result, "Min. received")).toBeUndefined();
+    });
+
+    // The input side of the same gap: the V4 step's swap actions spend USDC
+    // and DAI, two currencies that none of them buys, and nothing names its
+    // input side. The V3 step's WETH and its amount were shown instead.
+    test("a V4 step whose swap actions spend two currencies, then a V3 step, does not show the V3 step's input", () => {
+        const data = buildExecute(
+            solidityPacked(["uint8", "uint8"], [0x10, 0x00]),
+            [
+                encodeV4Swap(
+                    new Uint8Array([
+                        V4_SWAP_EXACT_IN_SINGLE_ID,
+                        V4_SWAP_EXACT_IN_SINGLE_ID,
+                        V4_CLOSE_CURRENCY_ID,
+                        V4_CLOSE_CURRENCY_ID,
+                        V4_CLOSE_CURRENCY_ID,
+                    ]),
+                    [
+                        // 500 USDC for at least 0.25 WETH
+                        encodeV4ExactInSingle(
+                            USDC_ADDR,
+                            WETH_ADDR,
+                            500000000n,
+                            250000000000000000n,
+                        ),
+                        // 500 DAI for at least 0.25 WETH
+                        encodeV4ExactInSingle(
+                            DAI_ADDR,
+                            WETH_ADDR,
+                            500000000000000000000n,
+                            250000000000000000n,
+                        ),
+                        encodeV4CloseCurrency(USDC_ADDR),
+                        encodeV4CloseCurrency(DAI_ADDR),
+                        encodeV4CloseCurrency(WETH_ADDR),
+                    ],
+                ),
+                encodeV3SwapExactIn(
+                    USER_ADDR,
+                    500000000000000000n,
+                    990000000n,
+                    [WETH_ADDR, USDT_ADDR],
+                ),
+            ],
+            9999999999n,
+        );
+        const result = uniswap.decode(data, ROUTER_ADDR);
+        expect(result.name).toBe("Uniswap Swap");
+        expect(detail(result, "Token In").value).toBe(
+            "Unknown (not named in the calldata)",
+        );
+        expect(detail(result, "Amount")).toBeUndefined();
+        expect(detail(result, "Token Out").address).toBe(
+            USDT_ADDR.toLowerCase(),
+        );
+        expect(detail(result, "Min. received").value).toBe("990.0000 USDT");
+    });
+
+    // UNWRAP_WETH makes Token Out ETH when no step set the output side. A V4
+    // step with a swap action did set it, to unknown here.
+    test("an UNWRAP_WETH after a V4 step whose swap actions buy two currencies does not make Token Out ETH", () => {
+        const data = buildExecute(
+            solidityPacked(["uint8", "uint8"], [0x10, 0x0c]),
+            [
+                WETH_FOR_USDC_AND_DAI,
+                encodeWrapEth(USER_ADDR, 0n), // UNWRAP_WETH, same encoding
+            ],
+            9999999999n,
+        );
+        const result = uniswap.decode(data, ROUTER_ADDR);
+        expect(detail(result, "Token Out").value).toBe(
+            "Unknown (not named in the calldata)",
+        );
+    });
+
+    // The router works through an exact-out path from its last entry back to
+    // its first: the WETH entry buys the USDC, then the USDT entry buys that
+    // WETH. The user pays the first entry's USDT, not the last entry's WETH.
+    test("a two-hop V4 exact-out action shows its first path entry as Token In", () => {
+        const data = buildExecute(
+            "0x10",
+            [
+                encodeV4Swap(new Uint8Array([0x09]), [
+                    // SWAP_EXACT_OUT: exactly 990 USDC for at most 1,000 USDT
+                    coder.encode(
+                        [`tuple(address,${PATH_KEY}[],uint128,uint128)`],
+                        [
+                            [
+                                USDC_ADDR,
+                                [
+                                    [USDT_ADDR, 100, 1, ZERO_ADDR, "0x"],
+                                    [WETH_ADDR, 100, 1, ZERO_ADDR, "0x"],
+                                ],
+                                990000000n,
+                                1000000000n,
+                            ],
+                        ],
+                    ),
+                ]),
+            ],
+            9999999999n,
+        );
+
+        const result = uniswap.decode(data, ROUTER_ADDR);
+        expect(result.name).toBe("Swap USDT → USDC");
+        expect(detail(result, "Token In").address).toBe(USDT_ADDR);
+        expect(detail(result, "Token Out").address).toBe(USDC_ADDR);
+    });
+
     // https://git.eeqj.de/sneak/AutistMask/issues/415 — the router's V2
     // exact-in reads an amountIn of zero as universal-router
     // Constants.ALREADY_PAID: an earlier step sent the tokens to the pair, and

tests/uniswapUndeterminedTokenIn.test.js

@@ -97,7 +97,11 @@ describe("an execute() whose input currency never decoded", () => {
         ]);
 
     test("says the input token is unknown instead of naming ETH", () => {
-        expect(detail(data(), "Token In").value).toBe(REFUSAL);
+        // The swap action that would name it could not be read, so the line
+        // says that rather than REFUSAL's "not named in the calldata".
+        expect(detail(data(), "Token In").value).toBe(
+            "Unknown (could not be decoded)",
+        );
     });
 
     test("keeps a Token In line, so the screen never omits what is paid", () => {

tests/wallet.test.js

@@ -416,7 +416,7 @@ describe("extended key depth", () => {
         expect(() =>
             wallet.getSignerForAddress(
                 { type: "xprv" },
-                0,
+                { address: VECTOR_ADDRESSES[0], index: 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" },
-            index,
+            { address: VECTOR_ADDRESSES[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" },
-            index,
+            { address: VECTOR_ADDRESSES[index], index },
             masterXprv(VECTOR_PHRASE),
         );
 
@@ -527,7 +527,7 @@ describe("getSignerForAddress", () => {
         for (const index of [0, 1, 2]) {
             const signer = wallet.getSignerForAddress(
                 { type: "privkey" },
-                index,
+                { address: VECTOR_ADDRESSES[1], index },
                 VECTOR_PRIVATE_KEYS[1],
             );
 
@@ -535,10 +535,54 @@ 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" },
-            1,
+            { address: VECTOR_ADDRESSES[1], index: 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, balance: "0.0000" }],
+        addresses: [{ address: firstAddress, index: 0, balance: "0.0000" }],
     };
 }
 
@@ -74,7 +74,11 @@ function brokenXprvWallet(name = "Imported xprv") {
         nextIndex: 1,
         encryptedSecret: "irrelevant-to-these-tests",
         addresses: [
-            { address: node.deriveChild(0).address, balance: "0.0000" },
+            {
+                address: node.deriveChild(0).address,
+                index: 0,
+                balance: "0.0000",
+            },
         ],
     };
 }
@@ -570,7 +574,7 @@ describe("no path throws an unhandled error for a defective wallet", () => {
         try {
             wallet.getSignerForAddress(
                 { type: "xprv" },
-                0,
+                brokenXprvWallet().addresses[0],
                 accountXprv(VECTOR_PHRASE),
             );
         } catch (e) {
@@ -585,7 +589,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" },
-            0,
+            healthyXprvWallet().addresses[0],
             masterXprv(VECTOR_PHRASE),
         );