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

The popup picked an active address only when it opened, so after the first
wallet was created nothing was active until a reopen: Home had no headline,
and Send and Receive refused. Each of the three import paths on AddWallet now
makes the new wallet's first address active when no address is. When the
phrase or xprv scan then replaces the address list with one that leaves that
address out, the new list's first address becomes active and the background
is told, as when the user picks an address on Home. The address scan stand-in
in the popup test boot now answers in the real scan's shape, which the phrase
and xprv imports read.

Model: opus-5-5

.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

README.md

@@ -362,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
@@ -479,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
@@ -542,6 +553,28 @@ 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 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`). 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
@@ -551,13 +584,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.
 
@@ -663,16 +699,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
@@ -722,11 +758,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.
@@ -821,8 +859,22 @@ on the next event. Two consequences shape every recurring job in the background:
   service worker at all — the one remaining user of it, `src/shared/ens.js`,
   runs only in the popup and is marked as such.
 
-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
@@ -908,8 +960,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
 
@@ -1125,14 +1185,18 @@ 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
-`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
-unwraps the WETH it did not spend shows USDC. The token permission warning on
-the signature screen has its own amount wording, including `Unknown`; the
-SignApproval section below describes it.
+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
+whose swap action could not be read still sets each side as a swap step does,
+and a side its `SETTLE` or `TAKE` did not name is then unknown: no other step's
+token or figure is shown for it. 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 unwraps the WETH it did not spend shows USDC. The token permission
+warning on the signature screen has its own amount wording, including `Unknown`;
+the SignApproval section below describes it.
 
 The swap's `Deadline` line is the router's deadline as a UTC date and time, e.g.
 `2026-02-27 08:25:51`. A JavaScript date reaches only to 275760-09-13 00:00:00
@@ -1488,8 +1552,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
@@ -1694,7 +1764,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
@@ -1741,7 +1815,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)
@@ -2080,14 +2156,19 @@ 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. 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
@@ -2221,6 +2302,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
@@ -2747,7 +2835,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
 

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,6 +22,8 @@ const { debugFetch, log } = require("../shared/log");
 const {
     verifySignedTx,
     verifySignature,
+    signedPrimaryType,
+    typedDataMessageRefusal,
     typedDataChainRefusal,
     failureIsRetryable,
     describeTxFailure,
@@ -44,6 +46,7 @@ const {
 
 const {
     actionApi,
+    getPlatformInfo,
     runtimeApi,
     tabsQuery,
     tabsSendMessage,
@@ -67,6 +70,33 @@ const connectedSites = {};
 // 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
@@ -423,7 +453,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 +476,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 +547,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 +590,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 +611,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 +631,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);
     });
@@ -1427,7 +1460,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 {
@@ -1436,7 +1476,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,
@@ -1787,18 +1833,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 });

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).
@@ -194,6 +195,9 @@ async function importMnemonic(ctx) {
     };
     state.wallets.push(wallet);
     state.hasWallet = true;
+    if (state.activeAddress === null) {
+        state.activeAddress = firstAddress;
+    }
     await saveState();
     clearViewStack();
     ctx.renderWalletList();
@@ -215,8 +219,16 @@ async function importMnemonic(ctx) {
             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);
@@ -254,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();
@@ -315,6 +330,9 @@ async function importXprvKey(ctx) {
     };
     state.wallets.push(wallet);
     state.hasWallet = true;
+    if (state.activeAddress === null) {
+        state.activeAddress = firstAddress;
+    }
     await saveState();
     clearViewStack();
     ctx.renderWalletList();
@@ -336,8 +354,15 @@ async function importXprvKey(ctx) {
             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/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

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/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.
@@ -824,6 +882,8 @@ function describeSigningFailure(response, fallbackMessage) {
 module.exports = {
     verifySignedTx,
     verifySignature,
+    signedPrimaryType,
+    typedDataMessageRefusal,
     typedDataChainRefusal,
     assertNoForbiddenFields,
     assertNothingUnchecked,

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.
@@ -235,6 +243,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 +274,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,6 +302,7 @@ module.exports = {
     actionApi,
     alarmsApi,
     extensionApi,
+    getPlatformInfo,
     hasBrowserNamespace,
     notify,
     runtimeApi,
@@ -271,10 +312,14 @@ module.exports = {
     storageRemove,
     storageSet,
     tabsApi,
+    tabsGetCurrent,
+    tabsGetZoom,
     tabsQuery,
     tabsSendMessage,
     windowsApi,
     windowsCreate,
+    windowsGetCurrent,
     windowsGetLastFocused,
     windowsRemove,
+    windowsUpdate,
 };

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
@@ -295,6 +300,24 @@ 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 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,
@@ -309,6 +332,10 @@ function decodeV4Swap(input) {
         let takeToken = null;
         let amountIn = null;
         let amountOutMin = null;
+        // Set when a swap action's parameters are not in the deployed shape
+        // (see decodeExactly()), so nothing was read from that action. SETTLE
+        // and TAKE may still name both currencies.
+        let swapUndecoded = false;
 
         for (let i = 0; i < actions.length; i++) {
             const actionId = actions[i];
@@ -337,7 +364,7 @@ function decodeV4Swap(input) {
                         //   tuple(address,uint24,int24,address,bytes)[] path,
                         //   uint128 amountIn, uint128 amountOutMin)
                         try {
-                            const s = coder.decode(
+                            const s = decodeExactly(
                                 [
                                     "tuple(address,tuple(address,uint24,int24,address,bytes)[],uint128,uint128)",
                                 ],
@@ -355,13 +382,13 @@ function decodeV4Swap(input) {
                                 amountOutMin = s[0][3];
                             }
                         } catch {
-                            // Fall through — SETTLE/TAKE will provide tokens
+                            swapUndecoded = true;
                         }
                     } else {
                         // ExactInputSingleParams: (tuple(address,address,uint24,int24,address) poolKey,
                         //   bool zeroForOne, uint128 amountIn, uint128 amountOutMin, bytes hookData)
                         try {
-                            const s = coder.decode(
+                            const s = decodeExactly(
                                 [
                                     "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
                                 ],
@@ -384,7 +411,7 @@ function decodeV4Swap(input) {
                                 amountOutMin = s[0][3];
                             }
                         } catch {
-                            // Fall through
+                            swapUndecoded = true;
                         }
                     }
                 } else if (
@@ -393,7 +420,7 @@ function decodeV4Swap(input) {
                 ) {
                     if (actionId === V4_SWAP_EXACT_OUT) {
                         try {
-                            const s = coder.decode(
+                            const s = decodeExactly(
                                 [
                                     "tuple(address,tuple(address,uint24,int24,address,bytes)[],uint128,uint128)",
                                 ],
@@ -405,11 +432,11 @@ function decodeV4Swap(input) {
                                 settleToken = path[path.length - 1][0];
                             }
                         } catch {
-                            // Fall through
+                            swapUndecoded = true;
                         }
                     } else {
                         try {
-                            const s = coder.decode(
+                            const s = decodeExactly(
                                 [
                                     "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
                                 ],
@@ -426,7 +453,7 @@ function decodeV4Swap(input) {
                                     ? poolKey[1]
                                     : poolKey[0];
                         } catch {
-                            // Fall through
+                            swapUndecoded = true;
                         }
                     }
                 }
@@ -440,6 +467,7 @@ function decodeV4Swap(input) {
             tokenOut: takeToken,
             amountIn,
             amountOutMin,
+            swapUndecoded,
         };
     } catch {
         return null;
@@ -465,6 +493,7 @@ function decode(data, toAddress, sources) {
         let minOutput = null;
         let hasUnwrapWeth = false;
         let hasV2ExactOut = false;
+        let swapUndecoded = false;
         const commandNames = [];
 
         // THE INVARIANT: an amount and the token it is counted in always come
@@ -567,7 +596,20 @@ function decode(data, toAddress, sources) {
 
                 if (cmdId === 0x10) {
                     const v4 = decodeV4Swap(inputs[i]);
-                    if (v4) {
+                    if (v4 && v4.swapUndecoded) {
+                        // The unread swap action named this step's currencies
+                        // and amounts, so the step is marked and still sets
+                        // both sides as a swap step does. A side its SETTLE or
+                        // TAKE did not name is set undetermined, not left to
+                        // an earlier or later step's token and figure.
+                        swapUndecoded = true;
+                        commandNames[i] += " (could not be decoded)";
+                        if (!inputEstablished) {
+                            setInput(v4.tokenIn, v4.amountIn);
+                        }
+                        outputToken = v4.tokenOut;
+                        minOutput = v4.amountOutMin;
+                    } else if (v4) {
                         setInputOnce(v4.tokenIn, v4.amountIn);
                         // Always update output: last swap step wins. A step
                         // that carries the Min. received figure but decoded no
@@ -591,16 +633,19 @@ 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 whose swap action went unread left
+        // it undetermined; 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 step
+        // whose swap action went unread did set it, to undetermined. 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 outputUnset =
+            !present(outputToken) && !present(minOutput) && !swapUndecoded;
         const inInfo = tokenInfo(inputToken, sources);
         const outInfo =
             hasUnwrapWeth && (outputIsWeth || outputUnset)
@@ -640,7 +685,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 +751,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)) {

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: {
@@ -384,13 +385,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 +879,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", () => {
@@ -1494,8 +1534,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(
@@ -1539,6 +1579,42 @@ describe("what the approval is verified against", () => {
         expect(pending.result()).toEqual({ error: { message: refusal } });
     });
 
+    // ethers signs a `bool` field sent as the string "false" as true, and one
+    // left out as false. The sign screen refuses both; a signature for either
+    // that reaches the background anyway is not handed to the page
+    // (https://git.eeqj.de/sneak/AutistMask/issues/552).
+    test.each([
+        [
+            '"false"',
+            "false",
+            'The field "approved" is not true or false, so this typed data cannot be signed.',
+        ],
+        [
+            "left out",
+            undefined,
+            'The field "approved" is missing from the message, so this typed data cannot be signed.',
+        ],
+    ])(
+        "typed data with a bool %s is refused, not handed back",
+        async (_, approved, refusal) => {
+            const data = JSON.parse(TYPED_DATA);
+            data.types.Note.push({ name: "approved", type: "bool" });
+            data.message.approved = approved;
+            const typedData = JSON.stringify(data);
+            const bg = loadBackground();
+            const pending = bg.requestTypedData(typedData);
+            await settle();
+
+            const { answer } = await answerTypedData(bg, pending, typedData);
+
+            expect(answer.sendResponse).toHaveBeenCalledWith({
+                error: refusal,
+                retryable: false,
+            });
+            expect(pending.result()).toEqual({ error: { message: refusal } });
+        },
+    );
+
     test("a sign request from another address raises no approval at all", async () => {
         const bg = loadBackground();
         const pending = bg.requestSign(other.address);
@@ -2854,7 +2930,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 () => {
@@ -2871,7 +2947,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();
@@ -2893,7 +2969,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/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/slowApproval.js

@@ -0,0 +1,530 @@
+// 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 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 with "Remember", so
+        // the connection is stored rather than held by the worker.
+        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 = true",
+        );
+        // 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",
+        );
+
+        // 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/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/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/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/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/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");
@@ -662,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

@@ -163,6 +163,122 @@ function encodeV4ExactInSingle(currency0, currency1, amountIn, amountOutMin) {
     );
 }
 
+// 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). The
+// decoder reads neither, so in a V4_SWAP of a swap action and these, only the
+// swap action names the currencies.
+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]);
+}
+
 function detail(result, label) {
     return result.details.find((d) => d.label === label);
 }
@@ -203,9 +319,157 @@ 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);
+        },
+    );
+
+    // 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 $action in the newer shape, then SETTLE_ALL and TAKE_ALL, says both tokens could not be decoded",
+        ({ 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").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 $action in the newer shape and TAKE_ALL, 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, V4_TAKE_ALL_ID]), [
+                        newer,
+                        encodeV4TakeAll(USDC_ADDR, 990000n),
+                    ]),
+                ],
+                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 $action in the newer shape and SETTLE_ALL, 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, V4_SETTLE_ALL_ID]), [
+                        newer,
+                        encodeV4SettleAll(WETH_ADDR, ONE_WETH),
+                    ]),
+                    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, V4_TAKE_ALL_ID]), [
+                    newer,
+                    encodeV4TakeAll(USDC_ADDR, 990000n),
+                ]),
+                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 +812,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",
         );
     });
 

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", () => {