fix: AutistMask does not run in Firefox private windows (closes #646)

Firefox gives an extension page in a private window locks of its own. A
popup there could save between the background's read and its write of the
stored record, and undo a network switch the background had saved.

manifest/firefox.json now sets "incognito": "not_allowed", so Firefox never
runs AutistMask in a private window. tests/manifest.test.js pins the key.
The README and five code comments no longer describe a private-window
exception to the lock.

Model: opus-5-5

Dockerfile

@@ -10,7 +10,6 @@ WORKDIR /app
 
 COPY script/ script/
 COPY package.json yarn.lock ./
-# yarn warns about the workspaces field in eslint and babel-plugin-istanbul; no newer release drops it.
 RUN script/bootstrap
 
 COPY . .

docs/RELEASE.md

@@ -1,225 +1,87 @@
 # Releasing AutistMask
 
-A release is a tagged commit on the `main` branch and the two archives that
-`make package` writes from that commit. This file is the procedure, in order.
+This is the procedure that turns a green `main` into a tagged, packaged release.
+It gathers into one place what is otherwise spread across the `Makefile` and
+three `README.md` sections, so the person cutting a release does not have to
+reconstruct the order from them.
 
-Only the owner ([@sneak](https://sneak.berlin)):
-
-- decides whether and when a release is tagged;
-- creates, moves or deletes a tag;
-- decides where the archives are published.
-
-Anyone can run steps 1 to 4. No script in this repository uploads or publishes
-the archives. None signs them, and none packs a CRX (Chrome's packaged extension
-file).
-
-## Terms
-
-- The tracker is the repository's Gitea site (Gitea is the software that hosts
-  the repository): https://git.eeqj.de/sneak/AutistMask. The tracker's Actions
-  page, https://git.eeqj.de/sneak/AutistMask/actions, lists the workflow runs.
-- A workflow is a file under `.gitea/workflows/` that lists jobs. The tracker
-  runs every workflow on each push. Each job runs one script on the tracker's
-  runner (the machine that runs jobs).
-- The release commit is a commit on `main`. Releases are tagged from `main` only
-  (`TODO.md`, Workflow).
-- A clean checkout is a working tree (the checked-out files) at the release
-  commit where `git status --porcelain` prints nothing. The build stamps the
-  commit hash (the commit's id) into the extension and appends `-dirty` when the
-  tree has local changes.
-- A tag is a name that git attaches to one commit. Release tags read `vX.Y.Z`,
-  such as `v0.1.0`.
-- A digest is the sha256 hash of a file (a fixed-length fingerprint of its
-  bytes), written as 64 hexadecimal characters.
-
-## What you need
-
-- A clean checkout of the release commit.
-- `make`.
-- Docker (a tool that runs programs in containers), for `script/cibuild` in
-  step 1. `make package` needs no Docker.
-- Node and yarn, on the `PATH`. `make package` runs both directly.
-  `script/bootstrap` can install both through nvm (a Node version manager), but
-  it leaves them off the `PATH`.
+There is one version, declared in three files (`package.json`,
+`manifest/chrome.json`, `manifest/firefox.json`), and `make package` builds and
+packages but publishes nothing. `make build` and `make package` can be run by
+anyone; tagging, signing, packing a CRX and any upload need credentials only the
+owner ([@sneak](https://sneak.berlin)) holds and are marked **owner-only**
+below. Releases are tagged from `main` (see the Workflow section of `TODO.md`),
+so the "release commit" throughout is the `main` commit the milestone PR merged.
 
 ## Procedure
 
-### 1. Confirm the release commit is green
+1. **Confirm `main` is green in CI.** The `check` workflow
+   (`.gitea/workflows/check.yml`) runs `script/cibuild`, which runs
+   `script/check` and then builds the image uncached, so a green `check` run is
+   a green `make check`. Find the run for the exact release commit on the
+   tracker's Actions view. _Check:_ that commit's `check` run succeeded; running
+   `make check` on a clean checkout of the commit reproduces it and exits 0.
 
-The `check` workflow (`.gitea/workflows/check.yml`) runs `script/cibuild` on
-every push. `script/cibuild` runs:
+2. **Confirm the version matches the intended tag.** `package.json`,
+   `manifest/chrome.json` and `manifest/firefox.json` must all declare the same
+   `X.Y.Z`. `make build` fails when they disagree, but nothing checks that they
+   equal the tag you mean to create — that is this manual step. _Check:_ all
+   three files read the same `X.Y.Z`, and it is the version you intend to tag
+   `vX.Y.Z`.
 
-- `script/bootstrap`, which installs the dependencies;
-- `script/check`, which is what `make check` runs;
-- the Docker image build (an image is Docker's packaged form of a program).
+3. **Build and package from a clean checkout of that commit.** From a fresh
+   clone, or a working tree with no local modifications (`git status` clean),
+   checked out at the release commit: run `make setup`, then `make package`.
+   `make package` runs `make build` first, so the archives can only be made from
+   a `dist/` verified against that build's own receipt as a release (not debug)
+   build. It writes three files into `release/`:
+   `autistmask-chrome-<version>.zip`, `autistmask-firefox-<version>.xpi`, and
+   `SHA256SUMS`. _Check:_ those three files exist and `<version>` in the archive
+   names is the version confirmed in step 2. The Firefox `.xpi` is **unsigned**
+   (see step 6 and "Installing on Firefox" in `README.md`).
 
-`script/check` runs:
+4. **Verify `SHA256SUMS`.** The archives are deterministic — sorted entries,
+   fixed timestamps, fixed compression — so a second `make package` from another
+   clean checkout of the same commit produces byte-identical files. Verify the
+   recorded digests against the files with `sha256sum -c SHA256SUMS`, run from
+   `release/`. To confirm reproducibility, run `make package` again on a
+   separate clean checkout and compare the digests. _Check:_ `sha256sum -c`
+   reports `OK` for every file, and an independent build's digests match.
 
-- `script/test`: the tests, in Docker;
-- `script/lint`, which runs three checks in Docker:
-    - ESLint, a code checker;
-    - `prettier --check .`, the formatting check;
-    - `script/check-censored`, which fails when the name that `RULES.md` bars
-      appears outside its allowed places;
-- `script/fmt-check`: `prettier --check .` again, on the host.
+5. **Tag the release commit.** _(owner-only)_ Create an annotated tag `vX.Y.Z`
+   on the release commit and push it: `git tag -a vX.Y.Z` (with a message), then
+   `git push origin vX.Y.Z`. _Check:_ `git tag` lists `vX.Y.Z`, and
+   `git rev-parse vX.Y.Z^{commit}` resolves to the release commit.
 
-The `e2e` workflow (`.gitea/workflows/e2e.yml`) has two jobs. One runs
-`script/test-e2e`, the browser tests in Chrome. The other runs
-`script/test-e2e-firefox`, the browser tests in Firefox. A red `e2e` job does
-not fail the `check` run.
+6. **Distribute per browser.** _(owner-only; pending the owner's choice on
+   https://git.eeqj.de/sneak/AutistMask/issues/386)_ How 1.0.0 is distributed on
+   each browser is not yet decided; it is the open question on that issue, and
+   the concrete steps cannot be written until the owner records a choice there.
+   These steps need credentials only the owner holds. The options under
+   consideration are:
+    - **Firefox** — the packaged `.xpi` is unsigned, and release Firefox and ESR
+      refuse an unsigned add-on:
+        - (a) AMO self-distribution signing (unlisted): submit the `.xpi` to AMO
+          with the owner's credentials; AMO returns a signed `.xpi` installable
+          on every Firefox, with nothing listed publicly.
+        - (b) AMO listed: as (a), plus a public AMO listing and review.
+        - (c) Ship the unsigned `.xpi` and state that Firefox support means
+          Developer Edition, Nightly, or an Unbranded build with
+          `xpinstall.signatures.required` set to `false`.
+    - **Chrome** — the repo packs no CRX and publishes nothing; the extension id
+      is fixed by the `key` in `manifest/chrome.json`:
+        - (a) Chrome Web Store (unlisted): upload the `.zip` with the owner's
+          developer account; the store delivers installs and updates.
+        - (b) Self-hosted CRX signed with the private key the owner holds
+          (`chrome --pack-extension=dist/chrome --pack-extension-key=<path to the .pem>`),
+          installable only via enterprise policy on Windows and macOS, so
+          realistically Linux-only.
+        - (c) "Load unpacked" from `dist/chrome/` only, as today.
 
-Run `script/cibuild` on the clean checkout. `script/cibuild` runs the same steps
-as the `check` run, and must exit 0.
-
-Check: on the Actions page, the `check` run for the release commit succeeded,
-and both `e2e` jobs for that commit succeeded. `script/cibuild` exited 0 on the
-clean checkout.
-
-### 2. Confirm the version
-
-Three files declare the version:
-
-- `package.json`;
-- `manifest/chrome.json`;
-- `manifest/firefox.json`.
-
-`script/lib/version.js` fails the build when the three disagree.
-`tests/version.test.js` fails when the version is not three numbers separated by
-dots. Nothing compares the version with a tag. That comparison is this step.
-
-Check: all three files read the same `X.Y.Z`, and `vX.Y.Z` is the tag that the
-owner creates in step 5.
-
-### 3. Build and package
-
-On the clean checkout, run:
-
-```bash
-make setup
-make package
-```
-
-`make setup` installs two things:
-
-- the dependencies, from the lockfile `yarn.lock`, which pins each one's
-  version;
-- the git pre-commit hook, a script that git runs before each commit. Here the
-  hook runs `script/check`.
-
-`make package` runs `make build`, then `script/lib/package.js`.
-
-`make build`:
-
-- runs `build.js`. `build.js` writes `dist/chrome/`, `dist/firefox/` and a build
-  receipt. The receipt lists every file that `build.js` wrote, with each file's
-  digest. The receipt lives outside the repository and is deleted when the build
-  ends;
-- runs `script/verify-build --expect release` against the receipt. The check
-  fails when:
-    - `dist/` differs from the receipt;
-    - a bundle (one JavaScript file built from many source files) was compiled
-      with the build-time constant `DEBUG` on;
-    - any file carries the test recovery phrase, which a debug build gives every
-      new wallet;
-- runs `script/check-censored --require-dist` against the built files;
-- removes `dist/` when any of those steps fails.
-
-`script/lib/package.js`:
-
-- empties `release/`;
-- refuses a symbolic link (a file that points at another file) under `dist/`;
-- checks that the browser's directory (`dist/chrome/` or `dist/firefox/`) holds
-  every file named in `manifest.json` or in the popup's HTML page.
-  `manifest.json` is the file that describes the extension to the browser. The
-  popup is the window that the toolbar button opens;
-- checks that the `version` in each `manifest.json` is the version from step 2;
-- writes one archive per browser;
-- reads each archive back;
-- compares every member (a file inside the archive) with `dist/` byte for byte;
-- writes `SHA256SUMS`, with one line per archive:
-    - the digest;
-    - two spaces;
-    - the file name.
-
-`make package` writes three files:
-
-```
-release/autistmask-chrome-<version>.zip
-release/autistmask-firefox-<version>.xpi
-release/SHA256SUMS
-```
-
-The `.xpi` is Firefox's add-on package file (an add-on is Firefox's word for an
-extension). The `.xpi` is not signed.
-
-`make package` prints a line that starts `Not shipped` and names `styles.css`.
-This is expected: each archive holds its own copy of the stylesheet.
-
-Check: `release/` holds those three files, and `<version>` in their names is the
-version from step 2.
-
-### 4. Verify the digests
-
-From `release/`, run `sha256sum -c SHA256SUMS`.
-
-The archives are deterministic for a given `dist/`: the same `dist/` always
-gives the same bytes. `script/lib/zip.js`:
-
-- sorts the members;
-- sets every member's timestamp (its recorded date) to 1980-01-01;
-- compresses each member the same way every time.
-
-`dist/` itself carries the build date. `build.js` compiles the build date, a UTC
-(universal time) day, into the extension. So two builds of the same commit on
-the same UTC day give byte-identical archives. Builds on different days differ.
-
-Check: `sha256sum -c` prints `OK` for both archives. On the same UTC day, a
-second `make package` from another clean checkout of the same commit gives the
-same `SHA256SUMS`.
-
-### 5. Tag the release commit
-
-Owner only. Only the owner decides whether and when a release is tagged. Only
-the owner creates, moves or deletes a tag. On the release commit, the owner
-runs:
-
-```bash
-git tag -a vX.Y.Z -m "AutistMask X.Y.Z"
-git push origin vX.Y.Z
-```
-
-`-a` makes an annotated tag: a tag that carries a message and records who made
-the tag and when. `v0.1.0` is one.
-
-Once the tag exists, `git describe --tags` on the release commit prints
-`vX.Y.Z`. `script/cibuild` and `script/docker` pass that value to the Docker
-image build as `VERSION`.
-
-Check: `git rev-parse vX.Y.Z^{commit}` prints the release commit's hash, and the
-tag is listed at https://git.eeqj.de/sneak/AutistMask/tags.
-
-### 6. Publish the archives
-
-Owner only. The owner decides where the archives are published. No script in
-this repository uploads or publishes them.
-
-Whoever receives an archive installs it as follows.
-
-Chrome loads the extension from a directory:
-
-- unzip the archive into a new, empty directory, for example
-  `unzip autistmask-chrome-0.1.0.zip -d autistmask-chrome`;
-- open `chrome://extensions/` and turn on "Developer mode";
-- click "Load unpacked" and pick that directory.
-
-Chrome then reports the extension id `gipbhkogfopeahplcjhipkgpcimdpkip`. The id
-is the fixed string that identifies the extension to Chrome; the `key` in
-`manifest/chrome.json` sets the id.
-
-Release builds of Firefox refuse to install an unsigned add-on. Desktop Firefox
-115 or newer, in any edition, loads the `.xpi` as a temporary add-on from the
-`about:debugging` page. Firefox unloads a temporary add-on when Firefox exits.
-The section "Installing on Firefox" in `README.md` has the details.
-
-Check: each archive installs on a fresh browser profile (a new, empty set of
-browser data) by the route above.
+    Once the owner decides, the chosen steps — including which credentials they
+    need and who holds them — are written into this section and `README.md`'s
+    installation sections are updated to match, which is part of the definition
+    of done of https://git.eeqj.de/sneak/AutistMask/issues/386. _Check:_ for a
+    store or AMO route, the artifact installs from the store or AMO on a clean
+    browser profile; for the CRX or unpacked route, the documented load succeeds
+    and Chrome reports the extension id `gipbhkogfopeahplcjhipkgpcimdpkip`.

eslint.config.js

@@ -153,7 +153,8 @@ module.exports = [
         },
     },
 
-    // The files in script/lib/ run on plain node too, and are never bundled.
+    // The helpers the script/ entrypoints call: plain node programs too, run
+    // from a shell script rather than from yarn, and never bundled.
     {
         files: ["script/lib/**/*.js"],
         languageOptions: {

package.json

@@ -6,8 +6,8 @@
     "license": "GPL-3.0",
     "private": true,
     "scripts": {
-        "test": "node script/lib/jest.js --maxWorkers=3",
-        "test:verbose": "node script/lib/jest.js --maxWorkers=3 --verbose",
+        "test": "jest --forceExit --maxWorkers=3",
+        "test:verbose": "jest --forceExit --maxWorkers=3 --verbose",
         "build": "node build.js",
         "lint": "eslint . && prettier --check .",
         "fmt": "prettier --write .",

script/bootstrap

@@ -118,7 +118,6 @@ ensure_yarn() {
     fi
 }
 
-# yarn warns about the workspaces field in eslint and babel-plugin-istanbul; no newer release drops it.
 install_js_deps() {
     if missing yarn && [ -s "$HOME/.nvm/nvm.sh" ]; then
         nvm_sh "nvm use $NODE_VERSION >/dev/null && cd \"$ROOT\" && \

script/lib/jest.js

@@ -1,40 +0,0 @@
-// Runs jest with the arguments it is given, and fails the run when jest had to
-// force-stop the worker process that ran a test file. Jest itself only prints a
-// warning when that happens, and its run still passes. The warning means a test
-// left a timer or another open handle running. The test scripts in package.json
-// run jest through this file.
-//
-// Jest runs inside this process and writes to the terminal directly, so its
-// output looks the same as a plain jest run. This file only checks each write
-// to stderr for the warning below.
-
-"use strict";
-
-// The start of the warning that jest prints on stderr after it force-stops a
-// worker process.
-const WORKER_WARNING = "A worker process has failed to exit gracefully";
-
-let forceStopped = false;
-
-const writeStderr = process.stderr.write.bind(process.stderr);
-process.stderr.write = (chunk, ...rest) => {
-    if (String(chunk).includes(WORKER_WARNING)) {
-        forceStopped = true;
-    }
-    return writeStderr(chunk, ...rest);
-};
-
-// Runs after jest has finished, as the process exits.
-process.on("exit", () => {
-    if (forceStopped) {
-        console.error(
-            "script/lib/jest.js: failing the run, because jest force-stopped " +
-                "a worker process. A test left a timer or another open " +
-                "handle running.",
-        );
-        process.exitCode = 1;
-    }
-});
-
-// Jest's own command-line program. It reads its arguments from process.argv.
-require("jest/bin/jest");

src/background/index.js

@@ -161,9 +161,9 @@ let txApprovalSlot = null;
 const APPROVAL_PENDING_CODE = -32002;
 
 // True at every moment this can be sent: the slot is taken immediately before
-// the transaction is populated, so the other request is being prepared, is on
-// screen, or waits with its window closed. It does not claim the other one is
-// displayed yet, because for the length of one network round trip it is not.
+// the transaction is populated, so the other request is either being prepared
+// or on screen. It does not claim the other one is displayed yet, because for
+// the length of one network round trip it is not.
 const TX_APPROVAL_PENDING_MESSAGE =
     "AutistMask handles one transaction at a time, and another one is" +
     " already in progress, so this one was not sent. Please finish that" +
@@ -383,26 +383,14 @@ async function proxyRpc(method, params) {
     return json.result;
 }
 
-// The approval the toolbar popup is set to open, or null while it opens the
-// wallet. Set only by updateToolbarPopup() and showInToolbarPopup().
+// The site-connection approval the toolbar popup is set to open, or null while
+// it opens the wallet. Set only by resetPopupUrl() and showInToolbarPopup().
 let toolbarPopupApprovalId = null;
 
-// Point the toolbar popup at the oldest pending approval whose window closed,
-// or at the wallet when there is none. The user can then answer that approval
-// from the toolbar popup. pendingApprovals lists approvals in the order they
-// were added, so the first one found is the oldest. An approval held by a
-// running attempt is skipped until that attempt ends.
-function updateToolbarPopup() {
-    const closed = Object.values(pendingApprovals).find(
-        (approval) => approval.windowClosed && !approval.attemptInFlight,
-    );
-    toolbarPopupApprovalId = closed ? closed.id : null;
+function resetPopupUrl() {
+    toolbarPopupApprovalId = null;
     if (actionNs && typeof actionNs.setPopup === "function") {
-        actionNs.setPopup({
-            popup: closed
-                ? "src/popup/index.html?approval=" + closed.id
-                : "src/popup/index.html",
-        });
+        actionNs.setPopup({ popup: "src/popup/index.html" });
     }
 }
 
@@ -432,16 +420,15 @@ function settleApproval(id, result, options) {
     // approval stops being alive.
     releaseTxApprovalSlotFor(id);
     approval.resolve(result);
-    updateToolbarPopup();
+    resetPopupUrl();
     return true;
 }
 
 // What a pending approval resolves to when it is given up on rather than
-// answered: a site-connection or network-switch window was closed, or the
-// window could not be opened at all. An address switch in the wallet gives up
-// pending approvals too. A tx or sign approval answers the requesting page in
-// EIP-1193 shape; a site-connection or network-switch approval answers its
-// handler in the shape the popup's decision has, as a refusal.
+// answered: the window was closed, or could not be opened at all. A tx or sign
+// approval answers the requesting page in EIP-1193 shape; a site-connection or
+// network-switch approval answers its handler in the shape the popup's
+// decision has, as a refusal.
 function abandonedResult(approval, code, message) {
     if (approval.type === "tx" || approval.type === "sign") {
         return { error: { code, message } };
@@ -449,9 +436,8 @@ function abandonedResult(approval, code, message) {
     return { approved: false, remember: false };
 }
 
-// A site-connection or network-switch window the user closed without answering
-// is a refusal by the user, which is 4001 and the wording every other rejection
-// path already uses.
+// A window the user closed without answering is a refusal by the user, which
+// is 4001 and the wording every other rejection path already uses.
 const APPROVAL_REJECTED_CODE = 4001;
 const APPROVAL_REJECTED_MESSAGE = "User rejected the request.";
 
@@ -479,16 +465,31 @@ const APPROVAL_WINDOW_FAILED_MESSAGE =
 function claimApproval(approval) {
     if (approval.attemptInFlight) return false;
     approval.attemptInFlight = true;
-    updateToolbarPopup();
     return true;
 }
 
 // Release an approval whose attempt failed in a way the user can retry.
-// Nothing was broadcast, so the next attempt may claim it. If the user closed
-// its window while the attempt ran, the toolbar popup opens it for that retry.
+// Nothing was broadcast, so the next attempt may claim it.
+//
+// Unless the window it would be retried in is already gone. The user closed it
+// while the attempt was running and settleApproval() declined then, correctly,
+// because the attempt still owned the approval; the attempt has now failed, so
+// nothing owns it and nothing can reach it. Left standing it would hold the
+// requesting page's promise open forever and, with it, the transaction
+// approval slot. It is settled here as the rejection the closed window
+// already meant.
 function releaseApproval(approval) {
     approval.attemptInFlight = false;
-    updateToolbarPopup();
+    if (approval.windowClosed) {
+        settleApproval(
+            approval.id,
+            abandonedResult(
+                approval,
+                APPROVAL_REJECTED_CODE,
+                APPROVAL_REJECTED_MESSAGE,
+            ),
+        );
+    }
 }
 
 // Open approval in a separate popup window, unless it is no longer pending.
@@ -711,7 +712,9 @@ function isExtensionSender(sender) {
 // had refused.
 //
 // TX and sign approvals do not decide here. They stay pending across a
-// disconnect, and across their window closing, until the user answers them.
+// disconnect. When their window closes, the windows.onRemoved listener below
+// rejects them, unless an approved attempt is still running, in which case
+// that attempt answers the page.
 runtime.onConnect.addListener((port) => {
     if (port.name.startsWith("approval:")) {
         const id = port.name.split(":")[1];
@@ -739,7 +742,9 @@ runtime.onConnect.addListener((port) => {
             const approval = pendingApprovals[id];
             if (approval) {
                 if (approval.type === "tx" || approval.type === "sign") {
-                    // It stays pending until the user answers it.
+                    // When its window closes, windows.onRemoved rejects it,
+                    // unless an approved attempt is still running, in which
+                    // case that attempt answers the page.
                     return;
                 }
                 settleApproval(id, { approved: false, remember: false });
@@ -1292,7 +1297,7 @@ async function broadcastAccountsChanged() {
             windowsRemove(approval.windowId).catch(() => {});
         }
     }
-    updateToolbarPopup();
+    resetPopupUrl();
     // An address switch ends every connection allowed without "Remember". This
     // waits on storage, so it comes after the pending approvals above, which
     // are still rejected the moment the switch arrives.
@@ -1484,44 +1489,36 @@ if (runtime.onStartup) {
 }
 startBackgroundJobs();
 
-// The toolbar popup keeps its URL when the worker stops. A worker that starts
-// holds no approvals, so the toolbar popup is pointed back at the wallet.
-updateToolbarPopup();
-
-// A transaction or signature approval stays pending when its window closes.
-// The browser can close that window when the user clicks away from it, for
-// example to copy the password from a password manager. The approval is marked
-// as closed, so the toolbar popup can open it (see updateToolbarPopup()). An
-// attempt already running when the window closes goes on and reports its
-// outcome to the page.
+// When approval window is closed without a response, treat as rejection.
+// "Without a response" is the operative part: the popup stays open across the
+// verify and broadcast it is waiting on, so a user closing an apparently-hung
+// window is an ordinary event with an attempt already in flight behind it.
+// settleApproval() refuses those, which leaves the attempt to report its real
+// outcome to the page — and the window is recorded as gone, so that an attempt
+// which then fails retryably settles instead of waiting in a window that no
+// longer exists.
 //
-// This listener rejects a site-connection or network-switch approval whose
-// window closes before its popup connected its port. Once the port is
-// connected, the approval is left to the port. That popup approves and closes
-// in the same breath, and this event races the decision on a channel of its
-// own — the same race the port exists to end. Its port disconnect says the
-// same thing this event does, in an order that is defined, so the disconnect is
-// left to say it. The window closing before any port connected is the one case
-// with nothing else to speak for it, and is rejected here so the dApp is not
-// left waiting on a window that is gone.
+// A site-connection or network-switch approval whose popup connected its port
+// is not decided here. That popup approves and closes in the same breath, and
+// this event races the decision on a channel of its own — the same race the
+// port exists to end. Its port disconnect says the same thing this event does,
+// in an order that is defined, so the disconnect is left to say it. The window
+// closing before any port connected is the one case with nothing else to speak
+// for it, and is rejected here so the dApp is not left waiting on a window that
+// is gone.
 if (windowsNs && windowsNs.onRemoved) {
     windowsNs.onRemoved.addListener((windowId) => {
         for (const [id, approval] of Object.entries(pendingApprovals)) {
             if (approval.windowId !== windowId) continue;
-            if (approval.type === "tx" || approval.type === "sign") {
-                approval.windowClosed = true;
-                updateToolbarPopup();
-                continue;
-            }
-            if (approval.portConnected) continue;
-            settleApproval(
-                id,
-                abandonedResult(
+            const decidedOnPort =
+                approval.type !== "tx" && approval.type !== "sign";
+            if (decidedOnPort && approval.portConnected) continue;
+            const rejection = abandonedResult(
                 approval,
                 APPROVAL_REJECTED_CODE,
                 APPROVAL_REJECTED_MESSAGE,
-                ),
             );
+            if (!settleApproval(id, rejection)) approval.windowClosed = true;
         }
     });
 }
@@ -1666,9 +1663,7 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
                 });
                 return false;
             }
-            // The popup waits for this answer before it closes its window.
-            sendResponse(null);
-            return false;
+            return true;
         }
 
         // The popup signs; it reports back here when it could not. Keep the
@@ -1868,8 +1863,7 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
                 });
                 return false;
             }
-            sendResponse(null);
-            return false;
+            return true;
         }
 
         // The popup signs; it reports back here when it could not. Keep the

src/popup/index.html

@@ -1994,11 +1994,10 @@
                         >Erasing the saved data deletes every wallet stored in
                         this browser.</strong
                     >
-                    Nothing on the blockchain changes and no money is moved. If
-                    you kept a copy of a wallet's recovery phrase, private key
-                    or extended private key, you can add that wallet again.
-                    Without that copy or the exported copy above, everything the
-                    wallet holds is gone forever.
+                    Nothing on the blockchain changes and no money is moved, but
+                    without the exported copy above, or the recovery phrase for
+                    each wallet written down, everything they hold is gone
+                    forever.
                 </p>
                 <p class="text-xs mb-1">
                     To confirm, type

src/popup/index.js

@@ -6,7 +6,6 @@ const {
     saveState,
     onSaveFailure,
     takeStoredNetwork,
-    clearBalanceNotFetched,
     loadState,
 } = require("../shared/state");
 const { StateUnusableError } = require("../shared/stateSchema");
@@ -66,14 +65,7 @@ function renderWalletList() {
 const pageClosed = new AbortController();
 window.addEventListener("pagehide", () => pageClosed.abort());
 
-// While a refresh runs, a request through ctx is not dropped. The request sets
-// refreshAgain, and one more refresh runs once the running one ends. Several
-// requests in that time lead to one more refresh, not several. An import asks
-// for a refresh after its address scan. A refresh already running does not
-// have the addresses the scan found
-// (https://git.eeqj.de/sneak/AutistMask/issues/581).
 let refreshInFlight = false;
-let refreshAgain = false;
 
 // The ten-second refresh startRefresh() starts, stopped when the popup moves to
 // the recovery screen: there is no profile left to refresh.
@@ -96,29 +88,15 @@ let refreshTimer = null;
 // removed meanwhile is left as it is. Blockscout may have answered before the
 // user turned "Use Blockscout" off. So the save drops every token the user has
 // not tracked if the stored setting is off by then.
-//
-// The save also deletes `balanceNotFetched` from each tracked token whose
-// balance this refresh read at every address. trackToken() in
-// src/popup/views/helpers.js sets that field. The save takes the field off the
-// matching tokens of the stored record (clearBalanceNotFetched() in
-// src/shared/state.js). The rest of the stored tracked token list stays as it
-// is.
-//
-// Once the save is done, the wallet list is drawn again. So are the balances
-// on AddressDetail or AddressToken when that screen is up. No other screen is
-// drawn again, DeleteAddress and its balance lines included.
 async function doRefreshAndRender() {
-    if (refreshInFlight) {
-        refreshAgain = true;
-        return;
-    }
+    if (refreshInFlight) return;
     refreshInFlight = true;
     try {
         await followStoredSettings();
         const networkId = state.networkId;
         const wallets = structuredClone(state.wallets);
-        const [, readTokens] = await Promise.all([
-            refreshPrices(pageClosed.signal),
+        await Promise.all([
+            refreshPrices(),
             refreshBalances(
                 wallets,
                 state.rpcUrl,
@@ -149,43 +127,33 @@ async function doRefreshAndRender() {
             if (!stored.useBlockscout) {
                 dropUntrackedTokens(state.wallets, stored.trackedTokens);
             }
-            clearBalanceNotFetched(stored, readTokens);
             state.lastBalanceRefresh = Date.now();
             return true;
         });
         renderWalletList();
-        if (state.currentView === "address") addressDetail.renderBalances();
-        if (state.currentView === "address-token") addressToken.renderBalance();
     } catch (e) {
-        // No caller waits for this function, so it must never reject. An
-        // unhandled rejection reports nothing. The save inside it reports its
-        // own failure through onSaveFailure() (see src/shared/state.js); what
-        // is left here is a failed network round trip, which the next tick
-        // retries.
+        // Every call site fires this and walks away — the boot below, the ten
+        // second interval, and eight views through ctx — so it must never
+        // reject: an unhandled rejection is not a report of anything. The save
+        // inside it reports its own failure through onSaveFailure() (see
+        // src/shared/state.js); what is left here is a failed network round
+        // trip, which the next tick retries.
         log.errorf("popup: background refresh failed:", e);
     } finally {
         refreshInFlight = false;
     }
-    if (refreshAgain) {
-        refreshAgain = false;
-        doRefreshAndRender();
-    }
 }
 
 // Refreshes now and every ten seconds from then on. Called once a wallet
 // exists: by init() when the popup opens with one, and by AddWallet when it
 // adds one, which in a popup that opened on Welcome is the first
-// (https://git.eeqj.de/sneak/AutistMask/issues/530). With the ten-second
-// refresh already started, it starts no second one. On the recovery screen it
-// does nothing.
+// (https://git.eeqj.de/sneak/AutistMask/issues/530). With the refresh already
+// running it starts no second one, and on the recovery screen it does nothing.
 function startRefresh() {
     if (!$("view-state-recovery").classList.contains("hidden")) return;
     doRefreshAndRender();
     if (refreshTimer === null) {
-        // A tick that finds a refresh running is dropped.
-        refreshTimer = setInterval(() => {
-            if (!refreshInFlight) return doRefreshAndRender();
-        }, 10000);
+        refreshTimer = setInterval(doRefreshAndRender, 10000);
     }
 }
 
@@ -313,9 +281,9 @@ async function followStoredSettings() {
 // 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. An approval can also show in the
-// toolbar popup, whose window is the user's browser window; that one is left
-// alone.
+// 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;

src/popup/views/addToken.js

@@ -1,29 +1,11 @@
-const {
-    $,
-    showView,
-    showFlash,
-    escapeHtml,
-    goBack,
-    trackToken,
-} = require("./helpers");
+const { $, showView, showFlash, escapeHtml, goBack } = require("./helpers");
 const { getTopTokens } = require("../../shared/tokenList");
 const { state, saveState, currentNetwork } = require("../../shared/state");
 const { lookupTokenInfo } = require("../../shared/balances");
 const { isScamAddress } = require("../../shared/scamlist");
-const { isSpoofedSymbol } = require("../../shared/symbolSpoof");
 const { log } = require("../../shared/log");
 
-// Counts the times AddToken has opened. A contract lookup started before
-// AddToken was last opened changes neither the screen nor the status line.
-let addTokenScreenOpenings = 0;
-
-function findTracked(address) {
-    const lower = address.toLowerCase();
-    return state.trackedTokens.find((t) => t.address.toLowerCase() === lower);
-}
-
 function show() {
-    addTokenScreenOpenings++;
     $("add-token-address").value = "";
     $("add-token-info").textContent = "";
     $("add-token-info").style.visibility = "hidden";
@@ -55,7 +37,9 @@ function init(ctx) {
             showFlash("Enter a valid contract address starting with 0x.");
             return;
         }
-        const already = findTracked(contractAddr);
+        const already = state.trackedTokens.find(
+            (t) => t.address.toLowerCase() === contractAddr.toLowerCase(),
+        );
         if (already) {
             showFlash(already.symbol + " is already being tracked.");
             return;
@@ -71,7 +55,6 @@ function init(ctx) {
         // The network the lookup asks, which Settings may switch away from
         // before it answers, as for a transaction in confirmTx.js.
         const chainId = currentNetwork().chainId;
-        const opening = addTokenScreenOpenings;
         try {
             const info = await lookupTokenInfo(
                 contractAddr,
@@ -88,29 +71,8 @@ function init(ctx) {
                 );
                 return;
             }
-            // Another click on Add may have tracked this token while this
-            // lookup waited.
-            const trackedMeanwhile = findTracked(contractAddr);
-            if (trackedMeanwhile) {
-                showFlash(
-                    trackedMeanwhile.symbol + " is already being tracked.",
-                );
-                if (addTokenScreenOpenings !== opening) return;
-                infoEl.textContent = "";
-                infoEl.style.visibility = "hidden";
-                return;
-            }
-            // The balance list never shows a token that the spoof rule
-            // refuses, so such a token is not tracked.
-            if (isSpoofedSymbol(info.symbol, contractAddr, chainId)) {
-                showFlash("Not added: this token fakes a known symbol.");
-                if (addTokenScreenOpenings !== opening) return;
-                infoEl.textContent = "";
-                infoEl.style.visibility = "hidden";
-                return;
-            }
             log.infof("Adding token", info.symbol, contractAddr);
-            trackToken({
+            state.trackedTokens.push({
                 address: contractAddr,
                 symbol: info.symbol,
                 decimals: info.decimals,
@@ -118,17 +80,6 @@ function init(ctx) {
             });
             await saveState();
             ctx.doRefreshAndRender();
-            // If the lookup answers after AddToken was opened again, the
-            // token is still added, but the screen and the status line stay
-            // as they are.
-            if (addTokenScreenOpenings !== opening) return;
-            // The lookup is over, so a later Back onto AddToken shows no
-            // status.
-            infoEl.textContent = "";
-            infoEl.style.visibility = "hidden";
-            // If the lookup answers while another screen shows, the token is
-            // still added but the screen does not change.
-            if (state.currentView !== "add-token") return;
             // Pop the stack (back to address detail) and re-render it
             // so the newly added token is visible immediately.
             if (state.viewStack.length > 0) {
@@ -149,7 +100,6 @@ function init(ctx) {
                     ? detail
                     : "Could not add the token.",
             );
-            if (addTokenScreenOpenings !== opening) return;
             infoEl.textContent = "";
             infoEl.style.visibility = "hidden";
         }

src/popup/views/addressDetail.js

@@ -22,7 +22,6 @@ const {
     filterTransactions,
 } = require("../../shared/transactions");
 const { resolveEnsNames } = require("../../shared/ens");
-const { storedNetworkIs } = require("../../shared/storedSettings");
 const {
     updateSendBalance,
     renderSendTokenSelect,
@@ -67,27 +66,11 @@ function show() {
     });
     $("address-line").dataset.full = addr.address;
     attachCopyHandlers($("address-line"));
+    const usdTotal = formatAddressTotal(getAddressValue(addr));
+    $("address-usd-total").innerHTML = escapeHtml(usdTotal) || " ";
     const ensEl = $("address-ens");
     // ENS is now shown inside renderAddressHtml, hide the separate element
     ensEl.classList.add("hidden");
-    renderBalances();
-    // Only Blockscout reports the tokens the user has not tracked.
-    $("address-tokens-note").classList.toggle("hidden", !!state.useBlockscout);
-    renderSendTokenSelect(addr);
-    $("tx-list").innerHTML =
-        '<div class="text-muted text-xs py-1">Loading...</div>';
-    showView("address");
-    loadTransactions(addr.address);
-}
-
-// The USD total and the balance list. Drawn again by each balance refresh
-// that returns while this screen is up (doRefreshAndRender() in
-// src/popup/index.js), which leaves the rest of the screen as it is.
-function renderBalances() {
-    const addr =
-        state.wallets[state.selectedWallet].addresses[state.selectedAddress];
-    const usdTotal = formatAddressTotal(getAddressValue(addr));
-    $("address-usd-total").innerHTML = escapeHtml(usdTotal) || "&nbsp;";
     $("address-balances").innerHTML = balanceLinesForAddress(
         addr,
         state.trackedTokens,
@@ -101,6 +84,13 @@ function renderBalances() {
                 ctx.showAddressToken();
             });
         });
+    // Only Blockscout reports the tokens the user has not tracked.
+    $("address-tokens-note").classList.toggle("hidden", !!state.useBlockscout);
+    renderSendTokenSelect(addr);
+    $("tx-list").innerHTML =
+        '<div class="text-muted text-xs py-1">Loading...</div>';
+    showView("address");
+    loadTransactions(addr.address);
 }
 
 let loadedTxs = [];
@@ -108,7 +98,6 @@ let loadedTxs = [];
 let ensNameMap = new Map();
 
 async function loadTransactions(address) {
-    const networkId = state.networkId;
     try {
         const rawTxs = await fetchRecentTransactions(
             address,
@@ -125,74 +114,43 @@ async function loadTransactions(address) {
         });
         const txs = result.transactions;
 
+        // Persist any newly discovered fraud contracts
+        if (result.newFraudContracts.length > 0) {
+            for (const addr of result.newFraudContracts) {
+                if (!state.fraudContracts.includes(addr)) {
+                    state.fraudContracts.push(addr);
+                }
+            }
+            await saveState();
+        }
+
+        loadedTxs = txs;
+
         // Collect ALL unique addresses (from + to) for ENS resolution so
         // that reverse lookups work for every displayed address, not just
         // the ones that were originally entered as ENS names.
         const counterparties = [
             ...new Set(txs.flatMap((tx) => [tx.from, tx.to].filter(Boolean))),
         ];
-        let names = new Map();
         if (counterparties.length > 0) {
             try {
-                names = await resolveEnsNames(
+                ensNameMap = await resolveEnsNames(
                     counterparties,
                     state.rpcUrl,
                     state.networkId,
                     ctx.pageClosed,
                 );
             } catch {
-                // The rows then show no ENS names.
+                ensNameMap = new Map();
             }
         }
 
-        // If the network changed during the lookups above, or the screen now
-        // shows another address, nothing is saved or drawn. See
-        // src/shared/storedSettings.js.
-        if (
-            state.networkId !== networkId ||
-            !(await storedNetworkIs(networkId)) ||
-            $("address-line").dataset.full !== address
-        ) {
-            return;
-        }
-
-        // Persist any newly discovered fraud contracts, inside the save and
-        // holding the lock. Nothing is added unless this page and the stored
-        // record both still name the request's network.
-        if (result.newFraudContracts.length > 0) {
-            let saved = false;
-            await saveState((stored) => {
-                if (state.networkId !== networkId) return false;
-                if (stored.networkId !== networkId) return false;
-                for (const addr of result.newFraudContracts) {
-                    if (!state.fraudContracts.includes(addr)) {
-                        state.fraudContracts.push(addr);
-                    }
-                }
-                saved = true;
-            });
-            // If the network changed while the save waited for the lock,
-            // nothing is drawn.
-            if (!saved) return;
-        }
-
-        loadedTxs = txs;
-        ensNameMap = names;
         renderTransactions(txs);
     } catch (e) {
         // Cancelled by the popup closing, not failed: see pageClosed in
         // src/popup/index.js.
         if (ctx.pageClosed.aborted) return;
         log.errorf("loadTransactions failed:", e.message);
-        // If the network changed, or the screen now shows another address,
-        // the failure is not shown.
-        if (
-            state.networkId !== networkId ||
-            !(await storedNetworkIs(networkId)) ||
-            $("address-line").dataset.full !== address
-        ) {
-            return;
-        }
         $("tx-list").innerHTML =
             '<div class="text-muted text-xs py-1">Failed to load transactions.</div>';
     }
@@ -329,4 +287,4 @@ function init(_ctx) {
     exportPrivkey.init();
 }
 
-module.exports = { init, show, renderBalances };
+module.exports = { init, show };

src/popup/views/addressToken.js

@@ -22,14 +22,13 @@ const {
     timeAgo,
 } = require("./helpers");
 const { state, saveState, currentNetwork } = require("../../shared/state");
-const { bundledToken, resolveSymbol } = require("../../shared/tokenList");
+const { TOKEN_BY_ADDRESS, resolveSymbol } = require("../../shared/tokenList");
 const { formatUsd, getPrice } = require("../../shared/prices");
 const {
     fetchRecentTransactions,
     filterTransactions,
 } = require("../../shared/transactions");
 const { resolveEnsNames } = require("../../shared/ens");
-const { storedNetworkIs } = require("../../shared/storedSettings");
 const {
     updateSendBalance,
     renderSendTokenSelect,
@@ -50,24 +49,37 @@ function show() {
     const addr = wallet.addresses[state.selectedAddress];
     const ai = state.selectedAddress;
     const tokenId = state.selectedToken;
-    const chainId = currentNetwork().chainId;
-    const knownToken = bundledToken(tokenId, chainId);
-    currentSymbol =
-        tokenId === "ETH"
-            ? nativeCurrency()
-            : resolveSymbol(
+
+    // Determine token symbol and balance
+    let symbol, amount, price;
+    const knownToken = TOKEN_BY_ADDRESS.get(tokenId.toLowerCase());
+    if (tokenId === "ETH") {
+        symbol = nativeCurrency();
+        amount = parseFloat(addr.balance || "0");
+        price = getPrice("ETH");
+    } else {
+        const tb = (addr.tokenBalances || []).find(
+            (t) => t.address.toLowerCase() === tokenId.toLowerCase(),
+        );
+        symbol = resolveSymbol(
             tokenId,
             addr.tokenBalances,
             state.trackedTokens,
-                  chainId,
         );
+        // null when the scale is unknown: no quantity to show, and none to
+        // price. balanceLine() states that rather than printing 0.0000.
+        amount = tb ? unknownableAmount(tb.balance) : 0;
+        price = getPrice(symbol);
+    }
+
+    currentSymbol = symbol;
 
     $("address-token-title").textContent =
         wallet.name +
         " \u2014 Address " +
         (ai + 1) +
         " \u2014 " +
-        displaySymbol(currentSymbol);
+        displaySymbol(symbol);
 
     // Blockie
     const blockieEl = $("address-token-jazzicon");
@@ -89,7 +101,13 @@ function show() {
     $("address-token-line").dataset.full = addr.address;
     attachCopyHandlers($("address-token-line"));
 
-    renderBalance();
+    // USD total for this token only
+    const usdVal = price && amount !== null ? amount * price : null;
+    const usdStr = formatUsd(usdVal);
+    $("address-token-usd-total").innerHTML = escapeHtml(usdStr) || " ";
+
+    // Single token balance line (no tokenId — not clickable here)
+    $("address-token-balance").innerHTML = balanceLine(symbol, amount, price);
 
     // Token contract details (ERC-20 only)
     const contractInfo = $("address-token-contract-info");
@@ -151,49 +169,7 @@ function show() {
     loadTransactions(addr.address, tokenId);
 }
 
-// The USD total and the balance line of the selected token. Drawn again by
-// each balance refresh that returns while this screen is up
-// (doRefreshAndRender() in src/popup/index.js), which leaves the rest of the
-// screen as it is.
-function renderBalance() {
-    const addr =
-        state.wallets[state.selectedWallet].addresses[state.selectedAddress];
-    const tokenId = state.selectedToken;
-    let amount, price;
-    if (tokenId === "ETH") {
-        amount = parseFloat(addr.balance || "0");
-        price = getPrice("ETH");
-    } else {
-        const id = tokenId.toLowerCase();
-        const tb = (addr.tokenBalances || []).find(
-            (t) => t.address.toLowerCase() === id,
-        );
-        const tracked = state.trackedTokens.find(
-            (t) => t.address.toLowerCase() === id,
-        );
-        // null when the scale is unknown, or when no refresh has read the
-        // balance of a token just added: no quantity to show, and none to
-        // price. balanceLine() states that rather than printing 0.0000.
-        if (tb) amount = unknownableAmount(tb.balance);
-        else amount = tracked && tracked.balanceNotFetched ? null : 0;
-        price = getPrice(tokenId);
-    }
-
-    // USD total for this token only
-    const usdVal = price && amount !== null ? amount * price : null;
-    const usdStr = formatUsd(usdVal);
-    $("address-token-usd-total").innerHTML = escapeHtml(usdStr) || " ";
-
-    // Single token balance line (no tokenId — not clickable here)
-    $("address-token-balance").innerHTML = balanceLine(
-        currentSymbol,
-        amount,
-        price,
-    );
-}
-
 async function loadTransactions(address, tokenId) {
-    const networkId = state.networkId;
     try {
         const rawTxs = await fetchRecentTransactions(
             address,
@@ -210,6 +186,16 @@ async function loadTransactions(address, tokenId) {
         });
         let txs = result.transactions;
 
+        // Persist any newly discovered fraud contracts
+        if (result.newFraudContracts.length > 0) {
+            for (const addr of result.newFraudContracts) {
+                if (!state.fraudContracts.includes(addr)) {
+                    state.fraudContracts.push(addr);
+                }
+            }
+            await saveState();
+        }
+
         // Filter to this token only
         if (tokenId === "ETH") {
             txs = txs.filter((tx) => tx.contractAddress === null);
@@ -221,75 +207,32 @@ async function loadTransactions(address, tokenId) {
             );
         }
 
+        loadedTxs = txs;
+
         // Collect ALL unique addresses for ENS resolution so reverse
         // lookups work for every displayed address.
         const counterparties = [
             ...new Set(txs.flatMap((tx) => [tx.from, tx.to].filter(Boolean))),
         ];
-        let names = new Map();
         if (counterparties.length > 0) {
             try {
-                names = await resolveEnsNames(
+                ensNameMap = await resolveEnsNames(
                     counterparties,
                     state.rpcUrl,
                     state.networkId,
                     ctx.pageClosed,
                 );
             } catch {
-                // The rows then show no ENS names.
+                ensNameMap = new Map();
             }
         }
 
-        // If the network changed during the lookups above, or the screen now
-        // shows another address or token, nothing is saved or drawn. See
-        // src/shared/storedSettings.js.
-        if (
-            state.networkId !== networkId ||
-            !(await storedNetworkIs(networkId)) ||
-            $("address-token-line").dataset.full !== address ||
-            state.selectedToken !== tokenId
-        ) {
-            return;
-        }
-
-        // Persist any newly discovered fraud contracts, inside the save and
-        // holding the lock. Nothing is added unless this page and the stored
-        // record both still name the request's network.
-        if (result.newFraudContracts.length > 0) {
-            let saved = false;
-            await saveState((stored) => {
-                if (state.networkId !== networkId) return false;
-                if (stored.networkId !== networkId) return false;
-                for (const addr of result.newFraudContracts) {
-                    if (!state.fraudContracts.includes(addr)) {
-                        state.fraudContracts.push(addr);
-                    }
-                }
-                saved = true;
-            });
-            // If the network changed while the save waited for the lock,
-            // nothing is drawn.
-            if (!saved) return;
-        }
-
-        loadedTxs = txs;
-        ensNameMap = names;
         renderTransactions(txs);
     } catch (e) {
         // Cancelled by the popup closing, not failed: see pageClosed in
         // src/popup/index.js.
         if (ctx.pageClosed.aborted) return;
         log.errorf("loadTransactions failed:", e.message);
-        // If the network changed, or the screen now shows another address or
-        // token, the failure is not shown.
-        if (
-            state.networkId !== networkId ||
-            !(await storedNetworkIs(networkId)) ||
-            $("address-token-line").dataset.full !== address ||
-            state.selectedToken !== tokenId
-        ) {
-            return;
-        }
         $("address-token-tx-list").innerHTML =
             '<div class="text-muted text-xs py-1">Failed to load transactions.</div>';
     }
@@ -405,4 +348,4 @@ function init(_ctx) {
     });
 }
 
-module.exports = { init, show, renderBalance };
+module.exports = { init, show };

src/popup/views/approval.js

@@ -55,7 +55,7 @@ const {
 } = require("../../shared/approvalVerify");
 const txStatus = require("./txStatus");
 const uniswap = require("../../shared/uniswap");
-const { runtimeApi, sendMessage } = require("../../shared/browserApi");
+const { notify, runtimeApi, sendMessage } = require("../../shared/browserApi");
 
 const erc20Iface = new Interface(ERC20_ABI);
 
@@ -1142,21 +1142,12 @@ function init(_ctx) {
         }
     });
 
-    // The window closes only once the background has the rejection. A message
-    // sent as the window closes can be lost, and a closed window does not
-    // reject the request. After Confirm, the background refuses a rejection
-    // while the transaction is being sent. The window then stays open and
-    // shows the background's message.
-    $("btn-reject-tx").addEventListener("click", async () => {
-        const response = await sendMessage({
+    $("btn-reject-tx").addEventListener("click", () => {
+        notify({
             type: "AUTISTMASK_TX_RESPONSE",
             id: approvalId,
             approved: false,
-        }).catch(() => null);
-        if (response && response.error) {
-            showError("approve-tx-error", response.error);
-            return;
-        }
+        });
         window.close();
     });
 
@@ -1279,18 +1270,12 @@ function init(_ctx) {
         if (outcome.retryable) setSignButtonBusy(false);
     });
 
-    // As for the transaction's Reject above. After Sign, the background
-    // refuses a rejection while the signature is being checked.
-    $("btn-reject-sign").addEventListener("click", async () => {
-        const response = await sendMessage({
+    $("btn-reject-sign").addEventListener("click", () => {
+        notify({
             type: "AUTISTMASK_SIGN_RESPONSE",
             id: approvalId,
             approved: false,
-        }).catch(() => null);
-        if (response && response.error) {
-            showError("approve-sign-error", response.error);
-            return;
-        }
+        });
         window.close();
     });
 }

src/popup/views/confirmTx.js

@@ -129,7 +129,7 @@ function renderAmount(txInfo) {
     const rawSymbol = isErc20
         ? txInfo.tokenSymbol || "?"
         : nativeCurrencyByChainId(txInfo.chainId);
-    const price = getPrice(txInfo.token, txInfo.chainId);
+    const price = getPrice(isErc20 ? rawSymbol : "ETH", txInfo.chainId);
     const amountUsd = price ? parseFloat(txInfo.amount) * price : null;
     $("confirm-amount").textContent = valueWithUsd(
         shownAmount(txInfo) + " " + displaySymbol(rawSymbol),
@@ -157,7 +157,7 @@ function renderBalance(txInfo) {
         $("confirm-balance").textContent = "unknown (" + symbol + ")";
         return;
     }
-    const price = getPrice(txInfo.token, txInfo.chainId);
+    const price = getPrice(isErc20 ? rawSymbol : "ETH", txInfo.chainId);
     const balUsd = price ? parseFloat(bal) * price : null;
     $("confirm-balance").textContent = valueWithUsd(
         truncateAmountNeverZero(bal) + " " + symbol,

src/popup/views/helpers.js

@@ -33,7 +33,6 @@ const { networkByChainId } = require("../../shared/networks");
 const { formatUsd, getPrice } = require("../../shared/prices");
 const { state, saveState, currentNetwork } = require("../../shared/state");
 const { displaySymbol } = require("../../shared/symbolDisplay");
-const { isSpoofedSymbol } = require("../../shared/symbolSpoof");
 const { walletHasRecoveryPhrase } = require("../../shared/wallet");
 const { markViewRendered } = require("../viewRouter");
 
@@ -314,17 +313,14 @@ function nativeCurrency() {
 // The wallets' balances hold what Blockscout reported for each token. So the
 // wallets are returned only while "Use Blockscout" is on.
 function tokenSourcesByChainId(chainId) {
-    const chainIdOrActive = chainId || currentNetwork().chainId;
-    const net = networkByChainId(chainIdOrActive);
+    const net = chainId ? networkByChainId(chainId) : currentNetwork();
     if (net && net.id === state.networkId) {
         return {
-            chainId: chainIdOrActive,
             trackedTokens: state.trackedTokens,
             wallets: state.useBlockscout ? state.wallets : [],
         };
     }
     return {
-        chainId: chainIdOrActive,
         trackedTokens: (net && state.networkTrackedTokens[net.id]) || [],
         wallets: [],
     };
@@ -355,7 +351,7 @@ function blockscoutOffTokenNoteHtml(token, chainId) {
 
 // The symbol shown for a token line, from these sources in order:
 //
-// - the bundled list, for a token on Ethereum Mainnet
+// - the bundled list
 // - the tokens the user tracks
 // - the explorer's report, while "Use Blockscout" is on
 //
@@ -421,15 +417,6 @@ function balanceLine(symbol, amount, price, tokenId) {
     );
 }
 
-// Tracks `token` on the active network, as every add path on AddToken and
-// SettingsAddToken does. The tracked record carries `balanceNotFetched: true`
-// until a balance refresh has read the token's balance at every address
-// (doRefreshAndRender() in src/popup/index.js). Until then, an address with no
-// balance row for the token shows `quantity unknown` for it, not 0.0000.
-function trackToken(token) {
-    state.trackedTokens.push({ ...token, balanceNotFetched: true });
-}
-
 function balanceLinesForAddress(addr, trackedTokens, showZero) {
     let html = balanceLine(
         nativeCurrency(),
@@ -452,7 +439,7 @@ function balanceLinesForAddress(addr, trackedTokens, showZero) {
         html += balanceLine(
             t.symbol,
             bal,
-            getPrice(t.address),
+            getPrice(t.symbol),
             t.address.toLowerCase(),
         );
         seen.add(t.address.toLowerCase());
@@ -460,17 +447,10 @@ function balanceLinesForAddress(addr, trackedTokens, showZero) {
     if (showZero && trackedTokens) {
         for (const t of trackedTokens) {
             if (seen.has(t.address.toLowerCase())) continue;
-            // A token that the spoof rule refuses has no stored balance, and
-            // gets no zero row either.
-            if (
-                isSpoofedSymbol(t.symbol, t.address, currentNetwork().chainId)
-            ) {
-                continue;
-            }
             html += balanceLine(
                 t.symbol,
-                t.balanceNotFetched ? null : 0,
-                getPrice(t.address),
+                0,
+                getPrice(t.symbol),
                 t.address.toLowerCase(),
             );
         }
@@ -849,7 +829,6 @@ module.exports = {
     flashCopyFeedback,
     balanceLine,
     balanceLinesForAddress,
-    trackToken,
     addressHoldsFunds,
     keyMaterialName,
     unknownableAmount,

src/popup/views/home.js

@@ -44,7 +44,6 @@ const {
     fetchRecentTransactions,
     filterTransactions,
 } = require("../../shared/transactions");
-const { storedNetworkIs } = require("../../shared/storedSettings");
 const { log } = require("../../shared/log");
 
 function findActiveAddr() {
@@ -184,7 +183,6 @@ async function loadHomeTxs(ctx) {
     }
     if (allAddresses.length === 0) return;
 
-    const networkId = state.networkId;
     const filters = {
         hideSpoofedSymbols: state.hideSpoofedSymbols,
         hideLowHolderTokens: state.hideLowHolderTokens,
@@ -204,15 +202,6 @@ async function loadHomeTxs(ctx) {
         );
         const results = await Promise.all(fetches);
 
-        // If the network changed during the lookups, nothing is saved or
-        // drawn. See src/shared/storedSettings.js.
-        if (
-            state.networkId !== networkId ||
-            !(await storedNetworkIs(networkId))
-        ) {
-            return;
-        }
-
         // Merge, deduplicate by hash, filter, sort, take 25
         const seen = new Set();
         let merged = [];
@@ -226,24 +215,14 @@ async function loadHomeTxs(ctx) {
 
         const filtered = filterTransactions(merged, filters);
 
-        // Persist any newly discovered fraud contracts, inside the save and
-        // holding the lock. Nothing is added unless this page and the stored
-        // record both still name the request's network.
+        // Persist any newly discovered fraud contracts
         if (filtered.newFraudContracts.length > 0) {
-            let saved = false;
-            await saveState((stored) => {
-                if (state.networkId !== networkId) return false;
-                if (stored.networkId !== networkId) return false;
             for (const addr of filtered.newFraudContracts) {
                 if (!state.fraudContracts.includes(addr)) {
                     state.fraudContracts.push(addr);
                 }
             }
-                saved = true;
-            });
-            // If the network changed while the save waited for the lock,
-            // nothing is drawn.
-            if (!saved) return;
+            await saveState();
         }
 
         merged = filtered.transactions;
@@ -255,13 +234,6 @@ async function loadHomeTxs(ctx) {
         // src/popup/index.js.
         if (ctx.pageClosed.aborted) return;
         log.errorf("loadHomeTxs failed:", e.message);
-        // If the network changed, the failure is not shown.
-        if (
-            state.networkId !== networkId ||
-            !(await storedNetworkIs(networkId))
-        ) {
-            return;
-        }
         const list = $("home-tx-list");
         if (list) {
             list.innerHTML =

src/popup/views/send.js

@@ -12,7 +12,7 @@ const {
     goBack,
     tokenSourcesByChainId,
 } = require("./helpers");
-const { state, currentAddress, currentNetwork } = require("../../shared/state");
+const { state, currentAddress } = require("../../shared/state");
 let ctx;
 const { getProvider } = require("../../shared/balances");
 const { resolveTokenDecimals } = require("../../shared/approvalAmount");
@@ -154,9 +154,7 @@ function renderSendTokenSelect(addr) {
         // out. Its token's own screen can still send it: there
         // state.selectedToken picks the token, not this list.
         if (isBelowOneMillionth(t.balance)) continue;
-        if (isSpoofedSymbol(t.symbol, t.address, currentNetwork().chainId)) {
-            continue;
-        }
+        if (isSpoofedSymbol(t.symbol, t.address)) continue;
         if (fraudSet.has(t.address.toLowerCase())) continue;
         // An unknown holder count does not withhold a token the user holds:
         // only a count the explorer actually reported as below the threshold
@@ -200,21 +198,13 @@ function renderSendTokenSelect(addr) {
 // null rather than "0": this screen states it as unknown, as the confirmation
 // screen does, and Max fills nothing in for it. Only a stored quantity is
 // withdrawn: the "0" for a token that has no row at all is an absence of
-// holdings, which is true at every scale. A token with no row whose tracked
-// record carries `balanceNotFetched` gets null instead, because no refresh has
-// read its balance.
+// holdings, which is true at every scale.
 function tokenBalanceAndDecimals(addr, token) {
     const tb = (addr.tokenBalances || []).find(
         (t) => t.address.toLowerCase() === token.toLowerCase(),
     );
     const tokenDecimals = resolveTokenDecimals(token, tokenSourcesByChainId());
-    if (!tb) {
-        const tracked = state.trackedTokens.find(
-            (t) => t.address.toLowerCase() === token.toLowerCase(),
-        );
-        const notRead = tracked && tracked.balanceNotFetched;
-        return { tokenBalance: notRead ? null : "0", tokenDecimals };
-    }
+    if (!tb) return { tokenBalance: "0", tokenDecimals };
     if (tokenDecimals === null) return { tokenBalance: null, tokenDecimals };
     return { tokenBalance: tb.balance ?? null, tokenDecimals };
 }
@@ -240,7 +230,6 @@ function updateSendBalance() {
             token,
             addr.tokenBalances,
             state.trackedTokens,
-            currentNetwork().chainId,
         );
         // A null balance is a holding whose scale is unknown. Saying a figure
         // for it would be a claim about the amount, so it reads as the
@@ -396,7 +385,6 @@ function init(_ctx) {
                 token,
                 addr.tokenBalances,
                 state.trackedTokens,
-                currentNetwork().chainId,
             );
             ({ tokenDecimals } = tokenBalanceAndDecimals(addr, token));
         }

src/popup/views/settings.js

@@ -44,17 +44,6 @@ let ctx;
 let versionClickCount = 0;
 let versionClickTimer = null;
 
-// The network that Settings was last drawn for. A follow of a switch saved
-// elsewhere sets `state` to the new network first. Settings is drawn again only
-// once the follow's write returns. So both "Save" buttons take this network,
-// not the one in `state`.
-let shownNetwork = null;
-
-// Each endpoint "Save" counts its taps here, under the field that it stores.
-// Once the user taps the same "Save" again, the earlier tap shows no flash
-// message. The earlier tap stores its URL only if its write had already begun.
-const saveTaps = { rpcUrl: 0, blockscoutUrl: 0 };
-
 // One row per site origin, however many addresses it appears under, each with
 // an [x] that hands it to onRemove.
 function renderSiteList(containerId, origins, onRemove) {
@@ -210,7 +199,6 @@ function renderWalletListSettings() {
 }
 
 function show() {
-    shownNetwork = currentNetwork();
     $("settings-rpc").value = state.rpcUrl;
     $("settings-blockscout").value = state.blockscoutUrl;
     $("settings-network").value = state.networkId;
@@ -318,7 +306,6 @@ function showNewSettings() {
         state.checkRecipientsOnEtherscan;
     if (state.currentView === "settings") {
         markViewRendered("settings");
-        shownNetwork = currentNetwork();
         $("settings-network").value = state.networkId;
         $("settings-rpc").value = state.rpcUrl;
         $("settings-blockscout").value = state.blockscoutUrl;
@@ -332,70 +319,17 @@ function showNewSettings() {
     updateDebugBanner(state.currentView);
 }
 
-// Saves `url` as `field` ("rpcUrl" or "blockscoutUrl") of the network
-// `networkId`, the one that Settings showed when the user tapped "Save". The
-// URL is set in `state` inside the save, holding the lock. So the page cannot
-// follow a switch saved elsewhere (followStoredSettings() in
-// src/popup/index.js) between setting the URL and writing it. If the active
-// network is no longer `networkId`, on this page or in the stored record,
-// nothing is saved. The flash message then says that the network changed.
-//
-// The save writes only the fields that differ from what this page last saved.
-// Another page may have stored a different URL since then. So `url` is set in
-// the stored record too. "Saved." then means that the stored record holds
-// `url`.
-//
-// `input` is the id of the input that the user typed `url` in. When another
-// page changes the network, "Use Blockscout" or "Check recipients on
-// Etherscan", this page draws Settings again. A redraw during the endpoint
-// check puts the URL from `state` back in the input. So if the input no longer
-// shows `url`, nothing is saved. The flash message then says that the URL was
-// changed during the check. The save compares the input and sets `url` in
-// `state` in one step. So a redraw after the comparison shows `url`.
-//
-// `tap` is the number of the "Save" tap that checked `url`. If the user taps
-// the same "Save" again before this save holds the lock, nothing is stored. If
-// the user taps the same "Save" again before the write ends, no flash message
-// is shown.
-async function saveEndpoint(field, input, url, networkId, tap) {
-    let refused = false;
-    let inputChanged = false;
-    await saveState((stored) => {
-        if (saveTaps[field] !== tap) return false;
-        refused =
-            state.networkId !== networkId || stored.networkId !== networkId;
-        inputChanged = $(input).value.trim() !== url;
-        if (refused || inputChanged) return false;
-        state[field] = url;
-        stored[field] = url;
-    });
-    if (saveTaps[field] !== tap) return;
-    if (refused) {
-        showFlash("The URL was not saved because the network changed.");
-    } else if (inputChanged) {
-        showFlash(
-            "The URL was not saved because it was changed during the check.",
-        );
-    } else {
-        showFlash("Saved.");
-    }
-}
-
 function init(_ctx) {
     ctx = _ctx;
     deleteWallet.init(ctx);
     showPhrase.init();
 
     $("btn-save-rpc").addEventListener("click", async () => {
-        saveTaps.rpcUrl++;
-        const tap = saveTaps.rpcUrl;
         const url = $("settings-rpc").value.trim();
         if (!url) {
             showFlash("Please enter an RPC URL.");
             return;
         }
-        // The URL is for the network that Settings shows when "Save" is tapped.
-        const net = shownNetwork;
         showFlash("Testing endpoint...");
         try {
             const resp = await debugFetch(url, {
@@ -409,13 +343,12 @@ function init(_ctx) {
                 }),
             });
             const json = await resp.json();
-            // The user has tapped this "Save" again since the check began.
-            if (tap !== saveTaps.rpcUrl) return;
             if (json.error) {
                 log.errorf("RPC validation error:", json.error);
                 showFlash("Endpoint returned an error.");
                 return;
             }
+            const net = currentNetwork();
             if (json.result !== net.chainId) {
                 showFlash("Wrong network: expected " + net.name + ".");
                 return;
@@ -424,7 +357,6 @@ function init(_ctx) {
             // Cancelled by the popup closing, not failed: see pageClosed in
             // src/popup/index.js.
             if (ctx.pageClosed.aborted) return;
-            if (tap !== saveTaps.rpcUrl) return;
             // Not the error's message: fetch puts the whole URL, password and
             // key included, in the message of the error it throws for a URL
             // with a user name and password or one it cannot parse.
@@ -432,41 +364,34 @@ function init(_ctx) {
             showFlash("Could not reach endpoint.");
             return;
         }
-        await saveEndpoint("rpcUrl", "settings-rpc", url, net.id, tap);
+        state.rpcUrl = url;
+        await saveState();
+        showFlash("Saved.");
     });
 
     $("btn-save-blockscout").addEventListener("click", async () => {
-        saveTaps.blockscoutUrl++;
-        const tap = saveTaps.blockscoutUrl;
         const url = $("settings-blockscout").value.trim();
         if (!url) {
             showFlash("Please enter a Blockscout API URL.");
             return;
         }
-        const net = shownNetwork;
         showFlash("Testing endpoint...");
         try {
             const resp = await debugFetch(url + "/stats");
-            if (tap !== saveTaps.blockscoutUrl) return;
             if (!resp.ok) {
                 showFlash("Endpoint returned HTTP " + resp.status + ".");
                 return;
             }
         } catch {
             if (ctx.pageClosed.aborted) return;
-            if (tap !== saveTaps.blockscoutUrl) return;
             // Not the error's message, as for the RPC check above.
             log.errorf("Blockscout validation failed:", urlOrigin(url));
             showFlash("Could not reach endpoint.");
             return;
         }
-        await saveEndpoint(
-            "blockscoutUrl",
-            "settings-blockscout",
-            url,
-            net.id,
-            tap,
-        );
+        state.blockscoutUrl = url;
+        await saveState();
+        showFlash("Saved.");
     });
 
     // Each change is made inside the save, holding the lock. So

src/popup/views/settingsAddToken.js

@@ -1,16 +1,8 @@
-const {
-    $,
-    showView,
-    showFlash,
-    escapeHtml,
-    goBack,
-    trackToken,
-} = require("./helpers");
+const { $, showView, showFlash, escapeHtml, goBack } = require("./helpers");
 const { getTopTokens } = require("../../shared/tokenList");
 const { state, saveState, currentNetwork } = require("../../shared/state");
 const { lookupTokenInfo } = require("../../shared/balances");
 const { isScamAddress } = require("../../shared/scamlist");
-const { isSpoofedSymbol } = require("../../shared/symbolSpoof");
 const { log } = require("../../shared/log");
 
 let ctx;
@@ -45,18 +37,13 @@ function renderTop10() {
     el.querySelectorAll(".settings-addtoken-quick:not([disabled])").forEach(
         (btn) => {
             btn.addEventListener("click", async () => {
-                // The button stays enabled until the first click's save ends.
-                if (isTracked(btn.dataset.address)) {
-                    showFlash("Already tracked.");
-                    return;
-                }
                 const token = {
                     address: btn.dataset.address,
                     symbol: btn.dataset.symbol,
                     decimals: parseInt(btn.dataset.decimals, 10),
                     name: btn.dataset.name || btn.dataset.symbol,
                 };
-                trackToken(token);
+                state.trackedTokens.push(token);
                 await saveState();
                 showFlash("Added " + token.symbol);
                 renderTop10();
@@ -123,7 +110,7 @@ function init(_ctx) {
             decimals: parseInt(opt.dataset.decimals, 10),
             name: opt.dataset.name || opt.dataset.symbol,
         };
-        trackToken(token);
+        state.trackedTokens.push(token);
         await saveState();
         showFlash("Added " + token.symbol);
         renderTop10();
@@ -168,26 +155,8 @@ function init(_ctx) {
                 );
                 return;
             }
-            // Another click on Add, or a "Top tokens:" button, may have
-            // tracked this token while this lookup waited.
-            if (isTracked(addr)) {
-                showFlash("Already tracked.");
-                infoEl.textContent = "";
-                infoEl.style.visibility = "hidden";
-                return;
-            }
-            // The balance list never shows a token that the spoof rule
-            // refuses, so such a token is not tracked. The rule never refuses
-            // a bundled token, so the "Top tokens:" buttons and the top 100
-            // dropdown need no such check.
-            if (isSpoofedSymbol(info.symbol, addr, chainId)) {
-                showFlash("Not added: this token fakes a known symbol.");
-                infoEl.textContent = "";
-                infoEl.style.visibility = "hidden";
-                return;
-            }
             log.infof("Adding token", info.symbol, addr);
-            trackToken({
+            state.trackedTokens.push({
                 address: addr,
                 symbol: info.symbol,
                 decimals: info.decimals,

src/popup/views/transactionDetail.js

@@ -311,21 +311,10 @@ function populateOnChainDetails(txData, chainId) {
     }
 }
 
-// Whether TransactionDetail still holds the transaction with `txHash` on
-// `chainId`. Opening another transaction replaces the one TransactionDetail
-// holds. A visit to Settings does not.
-function holdsTransaction(txHash, chainId) {
-    const tx = state.viewData.tx;
-    return tx?.hash === txHash && tx?.chainId === chainId;
-}
-
 // Reads the block, network details and calldata from Blockscout, and decodes
 // the calldata. While the stored "Use Blockscout" is off, Blockscout is not
 // asked. An answer that lands after the setting went off is dropped
 // (src/shared/storedSettings.js). Either way none of them is shown.
-//
-// Blockscout can answer after the user has opened another transaction. That
-// answer is dropped.
 async function loadFullTxDetails(txHash, chainId) {
     if (!(await storedSettingIsOn("useBlockscout"))) return;
     const section = $("tx-detail-calldata-section");
@@ -344,7 +333,6 @@ async function loadFullTxDetails(txHash, chainId) {
         if (!resp.ok) return;
         const txData = await resp.json();
         if (!(await storedSettingIsOn("useBlockscout"))) return;
-        if (!holdsTransaction(txHash, chainId)) return;
 
         // Populate on-chain detail fields (block, nonce, gas, fee)
         populateOnChainDetails(txData, chainId);

src/popup/views/txStatus.js

@@ -73,29 +73,6 @@ function toAddressHtml(address, chainId) {
     return renderAddressHtml(address, { title, chainId });
 }
 
-// The amount of each `Moved from the sender` line of a decoded swap, for the
-// wait and error screens to show under the Amount figure. That figure can leave
-// these amounts out, so alone it can read as less than can have left the
-// wallet. `decoded` can come back from storage in any shape, so this shows only
-// the lines whose value is text.
-function movedFromSenderHtml(decoded) {
-    if (!decoded || !Array.isArray(decoded.details)) return "";
-    let html = "";
-    for (const d of decoded.details) {
-        if (
-            !d ||
-            d.label !== "Moved from the sender" ||
-            typeof d.value !== "string"
-        )
-            continue;
-        html += `<div class="mt-2">`;
-        html += `<div class="text-xs text-muted mb-1">${escapeHtml(d.label)}</div>`;
-        html += `<div class="font-bold">${escapeHtml(d.value)}</div>`;
-        html += `</div>`;
-    }
-    return html;
-}
-
 function txHashHtml(hash, chainId) {
     const link = explorerUrl("tx", hash, chainId);
     return copyableHtml(hash, "break-all") + etherscanLinkHtml(link);
@@ -132,9 +109,10 @@ function startWait(txInfo, txHash, broadcastTime, pollNow) {
     }
     $("wait-tx-summary").textContent =
         txInfo.amount + (symbol ? " " + symbol : "");
-    $("wait-tx-token-note").innerHTML =
-        blockscoutOffTokenNoteHtml(txInfo.token, txInfo.chainId) +
-        movedFromSenderHtml(txInfo.decoded);
+    $("wait-tx-token-note").innerHTML = blockscoutOffTokenNoteHtml(
+        txInfo.token,
+        txInfo.chainId,
+    );
     $("wait-tx-to").innerHTML = toAddressHtml(txInfo.to, txInfo.chainId);
     $("wait-tx-hash").innerHTML = txHashHtml(txHash, txInfo.chainId);
     attachCopyHandlers("view-wait-tx");
@@ -245,7 +223,7 @@ function showWait(txInfo, txHash) {
 // to name a network. txInfo.token and txInfo.tokenSymbol are not checked here.
 // blockscoutOffTokenNoteHtml() shows no line for a token that is not text.
 // Everything else only compares and coalesces them, and tokenSymbol is null for
-// ETH. txInfo.decoded is not checked either: see movedFromSenderHtml().
+// ETH.
 function restoreWait() {
     const d = state.viewData;
     if (!d || !d.pendingWait) return false;
@@ -378,7 +356,6 @@ function showError(txInfo, txHash, message) {
         to: txInfo.to,
         hash: txHash || null,
         message: message,
-        decoded: txInfo.decoded || null,
         chainId: txInfo.chainId,
     };
     renderError();
@@ -389,9 +366,10 @@ function renderError() {
     if (!d || !d.message) return;
     $("error-tx-summary").textContent =
         d.amount + (d.symbol ? " " + d.symbol : "");
-    $("error-tx-token-note").innerHTML =
-        blockscoutOffTokenNoteHtml(d.token, d.chainId) +
-        movedFromSenderHtml(d.decoded);
+    $("error-tx-token-note").innerHTML = blockscoutOffTokenNoteHtml(
+        d.token,
+        d.chainId,
+    );
     $("error-tx-to").innerHTML = toAddressHtml(d.to, d.chainId);
     $("error-tx-message").textContent = d.message;
 

src/shared/approvalAmount.js

@@ -29,7 +29,7 @@
 // string, and a token the user added by hand carries whatever lookupTokenInfo()
 // got back, so the accepted types are enumerated rather than coerced.
 const { toDecimals } = require("./transferAmount");
-const { bundledToken } = require("./tokenList");
+const { TOKEN_BY_ADDRESS } = require("./tokenList");
 const { isSpoofedSymbol } = require("./symbolSpoof");
 
 // Every decimals the explorer reported for this contract, across all the
@@ -53,14 +53,12 @@ function explorerDecimals(lower, wallets) {
 }
 
 // The decimals to render a token amount with, or null when nothing knows.
-// `sources` is { chainId, trackedTokens, wallets }. `chainId` is the chain id
-// of the token's network. The bundled list is read only when that network is
-// Ethereum Mainnet. `trackedTokens` and `wallets` are shaped as on `state`.
+// `sources` is { trackedTokens, wallets }, both shaped as they are on `state`.
 function resolveTokenDecimals(tokenAddress, sources) {
     const lower = (tokenAddress || "").toLowerCase();
     if (!lower) return null;
 
-    const bundled = bundledToken(lower, sources && sources.chainId);
+    const bundled = TOKEN_BY_ADDRESS.get(lower);
     if (bundled) {
         const d = toDecimals(bundled.decimals);
         if (d !== null) return d;
@@ -102,19 +100,18 @@ function explorerSymbol(lower, wallets) {
 // explorer reported: the same sources and the same precedence
 // resolveTokenDecimals() uses, so a token's name and its scale are drawn from
 // the same place and the two can no longer disagree about which sources they
-// trust. `sources` is as for resolveTokenDecimals().
+// trust. `sources` is { trackedTokens, wallets }, shaped as on `state`.
 //
 // A tracked or explorer-reported symbol is attacker-influenced text, so it is
-// held to the spoof rule (symbolSpoof.js): a candidate that the rule calls a
-// spoof is refused and the next source tried, so resolving a symbol never
-// becomes a new way to claim a known ticker. The bundled list is the wallet's
-// own data and is trusted as it is.
+// held to the spoof rule (symbolSpoof.js): a candidate that wears a bundled or
+// native ticker from a contract not entitled to it is refused and the next
+// source tried, so resolving a symbol never becomes a new way to claim a known
+// ticker. The bundled list is the wallet's own data and is trusted as it is.
 function resolveTokenSymbol(tokenAddress, sources) {
     const lower = (tokenAddress || "").toLowerCase();
     if (!lower) return null;
 
-    const chainId = sources && sources.chainId;
-    const bundled = bundledToken(lower, chainId);
+    const bundled = TOKEN_BY_ADDRESS.get(lower);
     if (bundled && bundled.symbol) return bundled.symbol;
 
     const tracked = ((sources && sources.trackedTokens) || []).find(
@@ -126,7 +123,7 @@ function resolveTokenSymbol(tokenAddress, sources) {
     if (reported) candidates.push(reported);
 
     for (const symbol of candidates) {
-        if (!isSpoofedSymbol(symbol, tokenAddress, chainId)) return symbol;
+        if (!isSpoofedSymbol(symbol, tokenAddress)) return symbol;
     }
     return null;
 }

src/shared/balances.js

@@ -17,7 +17,7 @@ const { ERC20_ABI } = require("./constants");
 const { NETWORKS } = require("./networks");
 const { log, debugFetch, urlOrigin } = require("./log");
 const { deriveAddressFromXpub } = require("./wallet");
-const { bundledToken } = require("./tokenList");
+const { TOKEN_BY_ADDRESS } = require("./tokenList");
 const { LOW_HOLDER_THRESHOLD, parseHoldersCount } = require("./holders");
 const { isSpoofedSymbol } = require("./symbolSpoof");
 const { toDecimals } = require("./transferAmount");
@@ -106,9 +106,6 @@ function rawUnits(value) {
 // balance is read through the RPC endpoint instead, and its row here gives that
 // entry its holder count and `decimals` (fetchTrackedTokenBalances()).
 //
-// `chainId` is the chain id of the network `blockscoutUrl` serves. The known
-// token list is used only when that network is Ethereum Mainnet.
-//
 // `decimals` and `balance` are each null when the answer is unknown, the same
 // way `holders` already is. Absence is never filled in here: this is the
 // upstream of every screen that displays a token amount, so a value invented
@@ -120,7 +117,6 @@ async function fetchTokenBalances(
     address,
     blockscoutUrl,
     trackedTokens,
-    chainId,
     signal,
 ) {
     if (!(await storedSettingIsOn("useBlockscout"))) return [];
@@ -179,10 +175,7 @@ async function fetchTokenBalances(
             // either way: copying another source into it would make
             // explorerDecimals()'s disagreement check compare something other
             // than explorer values.
-            const known = resolveTokenDecimals(tokenAddr, {
-                chainId,
-                trackedTokens,
-            });
+            const known = resolveTokenDecimals(tokenAddr, { trackedTokens });
             const scale = known !== null ? known : decimals;
             // null is a holding of an amount that cannot be stated, which is
             // not the same as a holding of zero, and must never render as one.
@@ -198,7 +191,7 @@ async function fetchTokenBalances(
             // through to the views, where the two low-holder filters treat
             // an unknown count as "do not judge" rather than as zero.
             const holders = parseHoldersCount(item.token.holders_count);
-            const isKnown = bundledToken(tokenAddr, chainId) !== null;
+            const isKnown = TOKEN_BY_ADDRESS.has(tokenAddr);
             const isTracked = trackedSet.has(tokenAddr);
             const hasEnoughHolders = holders >= LOW_HOLDER_THRESHOLD;
 
@@ -209,9 +202,7 @@ async function fetchTokenBalances(
             // Every row here is an ERC-20 the explorer reported, so it has a
             // contract address; the native ETH balance is fetched over RPC in
             // refreshBalances and never passes through this loop.
-            if (isSpoofedSymbol(item.token.symbol, tokenAddr, chainId)) {
-                continue;
-            }
+            if (isSpoofedSymbol(item.token.symbol, tokenAddr)) continue;
 
             balances.push({
                 address: item.token.address_hash,
@@ -256,24 +247,19 @@ async function fetchTokenBalances(
 // it has none. The failure is logged. A balance of zero gets no entry, as a
 // zero Blockscout reports gets none: the balance lists take a tracked token's
 // zero from the tracked list. A token whose symbol the spoof rule refuses gets
-// no entry either, as in fetchTokenBalances(), and its balance is not read.
+// no entry either, as in fetchTokenBalances().
 //
-// Resolves with `rows`, the entries, and `unread`, the tracked tokens whose
-// balance was not read, as lowercased contract addresses. A token is unread
-// when the spoof rule refuses it or its balanceOf fails.
-//
-// `chainId` and `signal` are as for fetchTokenBalances().
+// `signal` is as for fetchTokenBalances().
 async function fetchTrackedTokenBalances(
     provider,
     address,
     trackedTokens,
     previous,
     explorerRequest,
-    chainId,
     signal,
 ) {
     const listed = trackedTokens.filter(
-        (token) => !isSpoofedSymbol(token.symbol, token.address, chainId),
+        (token) => !isSpoofedSymbol(token.symbol, token.address),
     );
     // Each token's balanceOf answer, or null where it failed.
     const balances = await Promise.all(
@@ -302,16 +288,12 @@ async function fetchTrackedTokenBalances(
     const reported = explorerRows ?? previous;
 
     const rows = [];
-    const unread = trackedTokens
-        .filter((token) => !listed.includes(token))
-        .map((token) => token.address.toLowerCase());
     listed.forEach((token, i) => {
         const lower = token.address.toLowerCase();
         const entryIn = (list) =>
             list.find((row) => String(row.address).toLowerCase() === lower);
         const raw = balances[i];
         if (raw === null) {
-            unread.push(lower);
             const kept = entryIn(previous) || entryIn(explorerRows || []);
             if (kept) rows.push(kept);
             return;
@@ -319,7 +301,7 @@ async function fetchTrackedTokenBalances(
         if (raw === 0n) return;
         const entry = entryIn(reported);
         const decimals = entry ? entry.decimals : null;
-        const known = resolveTokenDecimals(lower, { chainId, trackedTokens });
+        const known = resolveTokenDecimals(lower, { trackedTokens });
         const scale = known !== null ? known : decimals;
         rows.push({
             address: token.address,
@@ -332,15 +314,12 @@ async function fetchTrackedTokenBalances(
             holders: entry ? entry.holders : null,
         });
     });
-    return { rows, unread };
+    return rows;
 }
 
 // Fetch ETH balances, ENS names, and ERC-20 token balances for all addresses.
 // `trackedTokens` are the tokens tracked on the active network. `signal` is as
 // for fetchTokenBalances().
-//
-// Resolves with the lowercased contract addresses of the tracked tokens whose
-// balance it read at every address.
 async function refreshBalances(
     wallets,
     rpcUrl,
@@ -351,11 +330,8 @@ async function refreshBalances(
 ) {
     log.debugf("refreshBalances start, rpc:", urlOrigin(rpcUrl));
     const provider = getProvider(rpcUrl, networkId);
-    const { chainId } = requireNetworkId(networkId);
     const tracked = trackedTokens || [];
     const trackedSet = new Set(tracked.map((t) => t.address.toLowerCase()));
-    // The tracked tokens whose balance was not read at some address.
-    const unread = new Set();
     const updates = [];
 
     for (const wallet of wallets) {
@@ -417,7 +393,6 @@ async function refreshBalances(
                 addr.address,
                 blockscoutUrl,
                 tracked,
-                chainId,
                 signal,
             );
             updates.push(
@@ -428,18 +403,15 @@ async function refreshBalances(
                         tracked,
                         previous,
                         explorerRequest,
-                        chainId,
                         signal,
                     ),
                     explorerRequest,
-                ]).then(([trackedResult, explorerRows]) => {
-                    for (const lower of trackedResult.unread) unread.add(lower);
+                ]).then(([trackedRows, explorerRows]) => {
                     const untrackedRows = (explorerRows ?? previous).filter(
                         (row) =>
                             !trackedSet.has(String(row.address).toLowerCase()),
                     );
-                    addr.tokenBalances =
-                        trackedResult.rows.concat(untrackedRows);
+                    addr.tokenBalances = trackedRows.concat(untrackedRows);
                     log.debugf(
                         "Token balances",
                         addr.address,
@@ -453,7 +425,6 @@ async function refreshBalances(
 
     await Promise.all(updates);
     log.debugf("refreshBalances done");
-    return [...trackedSet].filter((lower) => !unread.has(lower));
 }
 
 // Drops the balance of each token not in `trackedTokens` from every address.

src/shared/chainSwitch.js

@@ -47,63 +47,12 @@ function clearPopupCaches() {
 // lock, so it is never switched while a follow of a switch saved elsewhere
 // waits for the lock (followStoredSettings() in src/popup/index.js): that
 // follow runs first, and this switch is made after it.
-//
-// The save writes only the fields that differ from what this page last saved.
-// When this page last saved a balance of "0", clearing that balance is no
-// change. So the switch also resets these fields in the stored record:
-//
-// - every address's balance and token balances;
-// - the time of the last balance refresh;
-// - the fraud contracts.
-//
-// A balance or a fraud contract that the background or another page stored
-// since this page's last save is then not kept under the new network
-// (https://git.eeqj.de/sneak/AutistMask/issues/653,
-// https://git.eeqj.de/sneak/AutistMask/issues/692).
-//
-// When the stored record is on another network, a switch saved elsewhere has
-// not reached this page yet. This page first takes that switch with
-// takeStoredNetwork() (state.js), as followStoredSettings() does. The switch to
-// `newNetworkId` is then made from the stored record's network. So every
-// network's list of tracked tokens in the stored record is kept
-// (https://git.eeqj.de/sneak/AutistMask/issues/701). When the stored record is
-// already on `newNetworkId`, the switch made from there only resets the
-// balances and caches.
-//
-// When the stored record is on this page's network, this page first takes the
-// stored `networkTrackedTokens` (takeStoredNetworkTrackedTokens() in state.js),
-// because another page's save may have changed a list this page holds.
-//
-// Before the switch, `state` takes the tracked tokens that another page stored
-// since this page's last save (takeStoredTrackedTokens() in state.js). The
-// switch then puts them away under the previous network, the network they were
-// added on.
 async function onChainSwitch(newNetworkId) {
-    const {
-        state,
-        saveState,
-        takeStoredNetwork,
-        takeStoredTrackedTokens,
-        takeStoredNetworkTrackedTokens,
-    } = require("./state");
+    const { state, saveState } = require("./state");
     let net = null;
-    await saveState((stored) => {
+    await saveState(() => {
         if (state.networkId === newNetworkId) return false;
-        if (stored.networkId !== state.networkId) {
-            takeStoredNetwork(stored);
-        } else {
-            takeStoredNetworkTrackedTokens(stored);
-        }
-        takeStoredTrackedTokens(stored);
         net = applyChainSwitchFields(state, newNetworkId);
-        stored.lastBalanceRefresh = 0;
-        stored.fraudContracts = [];
-        for (const wallet of stored.wallets) {
-            for (const addr of wallet.addresses) {
-                addr.balance = "0";
-                addr.tokenBalances = [];
-            }
-        }
         clearPopupCaches();
     });
     return net;

src/shared/chainSwitchFields.js

@@ -42,15 +42,11 @@ function applyChainSwitchFields(s, newNetworkId) {
     // Tracked tokens are kept per network the same way, because a contract
     // address names a token on one network only. s.trackedTokens stays the
     // active network's list, so nothing that reads it changes: the outgoing
-    // list is put away under its network, and a copy of the incoming network's
-    // list, or an empty list, takes its place.
-    //
-    // It is a copy because a save writes a changed s.networkTrackedTokens whole,
-    // over any list another page stored. An add or removal on the active network
-    // must change only s.trackedTokens.
+    // list is put away under its network, and the incoming network's list, or
+    // an empty one, takes its place.
     if (!s.networkTrackedTokens) s.networkTrackedTokens = {};
     s.networkTrackedTokens[s.networkId] = s.trackedTokens;
-    s.trackedTokens = structuredClone(s.networkTrackedTokens[net.id] || []);
+    s.trackedTokens = s.networkTrackedTokens[net.id] || [];
 
     s.networkId = net.id;
     s.rpcUrl = remembered.rpcUrl || net.defaultRpcUrl;

src/shared/prices.js

@@ -1,105 +1,31 @@
-// USD prices, read from Chainlink price feeds on Ethereum mainnet, with USD
-// formatting and value aggregation. The feeds are in src/shared/tokenList.js.
+// Price fetching with 5-minute cache, USD formatting, value aggregation.
 
-const { Contract } = require("ethers");
-const { ETH_USD_FEED, PRICE_FEED_BY_ADDRESS } = require("./tokenList");
-const { getProvider } = require("./balances");
+const { getTopTokenPrices } = require("./tokenList");
 const { isBelowOneMillionth } = require("./amountDisplay");
 const { networkByChainId } = require("./networks");
-const { log } = require("./log");
 
 const PRICE_CACHE_TTL = 300000; // 5 minutes
 
-// A reading older than its feed's heartbeat plus this many seconds is no price.
-const STALE_MARGIN = 1800; // 30 minutes
-
-const FEED_ABI = [
-    "function latestRoundData() view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)",
-];
-
-// USD prices: ether's under "ETH", each token's under its lowercased contract
-// address.
 const prices = {};
 let lastFetchedAt = 0;
 
-// Reads the price of ether and of each token any address holds or the user
-// tracks, when that token has a feed. Mainnet only. The reads go to the RPC
-// endpoint as one batched request, at most every 5 minutes. A failed read is
-// logged, and that token then has no price.
-//
-// `signal`, passed by the popup, is aborted when the popup closes. A read that
-// fails once `signal` is aborted is not logged, because closing the popup
-// cancelled it.
-async function refreshPrices(signal) {
-    const { state, currentNetwork } = require("./state");
-    if (currentNetwork().id !== "mainnet") {
+async function refreshPrices() {
+    // Testnet tokens have no real market value — skip price fetching
+    // and clear any stale mainnet prices so the UI shows no USD values.
+    const { currentNetwork } = require("./state");
+    if (currentNetwork().isTestnet) {
         clearPrices();
         return;
     }
     const now = Date.now();
     if (now - lastFetchedAt < PRICE_CACHE_TTL) return;
-    const feeds = new Map([["ETH", ETH_USD_FEED]]);
-    for (const address of heldOrTrackedTokens(state)) {
-        const feed = PRICE_FEED_BY_ADDRESS.get(address);
-        if (feed) feeds.set(address, feed);
-    }
-    // ethers sends calls made together on one provider as one batch.
-    const provider = getProvider(state.rpcUrl, state.networkId);
-    const read = {};
-    await Promise.all(
-        [...feeds].map(async ([key, feed]) => {
     try {
-                const contract = new Contract(feed.address, FEED_ABI, provider);
-                const round = await contract.latestRoundData();
-                const price = priceFromRound(round, feed, now);
-                if (price === null) {
-                    log.warnf(
-                        "price feed reading is stale or not positive",
-                        key,
-                    );
-                    return;
-                }
-                read[key] = price;
-            } catch (e) {
-                if (signal?.aborted) return;
-                log.errorf(
-                    "price feed read failed",
-                    key,
-                    e.shortMessage || e.message,
-                );
-            }
-        }),
-    );
-    clearPrices();
-    Object.assign(prices, read);
+        const fetched = await getTopTokenPrices(25);
+        Object.assign(prices, fetched);
         lastFetchedAt = now;
+    } catch {
+        // prices stay stale on error
     }
-
-// The lowercased contract address of each token that any address holds or
-// that the user tracks.
-function heldOrTrackedTokens(state) {
-    const addresses = new Set();
-    for (const wallet of state.wallets) {
-        for (const addr of wallet.addresses) {
-            for (const token of addr.tokenBalances || []) {
-                addresses.add(token.address.toLowerCase());
-            }
-        }
-    }
-    for (const token of state.trackedTokens || []) {
-        addresses.add(token.address.toLowerCase());
-    }
-    return addresses;
-}
-
-// The USD price in a feed's latestRoundData() result, or null when the answer
-// is not positive or was written longer ago than the feed's heartbeat plus
-// STALE_MARGIN. `now` is in milliseconds.
-function priceFromRound(round, feed, now) {
-    const ageSeconds = now / 1000 - Number(round.updatedAt);
-    if (ageSeconds > feed.heartbeat + STALE_MARGIN) return null;
-    if (round.answer <= 0n) return null;
-    return Number(round.answer) / 10 ** feed.decimals;
 }
 
 // Clear all cached prices and reset the fetch timestamp so the
@@ -111,15 +37,14 @@ function clearPrices() {
     lastFetchedAt = 0;
 }
 
-// Return the USD price of the token at the contract address `token`, or of
-// ether when `token` is "ETH". The price is for the network with `chainId`, or
-// for the active network when no chain id is given. Returns null on testnet,
-// on a chain id that names no network, and for a token with no price.
-function getPrice(token, chainId) {
+// Return the USD price for a symbol on the network with `chainId`, or on the
+// active network when no chain id is given; null on testnet, on a chain id
+// that names no network, or for a symbol with no price.
+function getPrice(symbol, chainId) {
     const { currentNetwork } = require("./state");
     const network = chainId ? networkByChainId(chainId) : currentNetwork();
     if (!network || network.isTestnet) return null;
-    return prices[token === "ETH" ? "ETH" : token.toLowerCase()] || null;
+    return prices[symbol] || null;
 }
 
 function formatUsd(amount) {
@@ -137,7 +62,7 @@ function formatUsd(amount) {
 
 // What an address is worth, as { usd, partial }.
 //
-// Only a token with a price feed has a price, so an address can hold real
+// Prices are fetched for the top 25 tokens only, so an address can hold real
 // assets this code has no price for. Adding up the priced ones and calling the
 // result the total states a number the holdings do not support: an address
 // holding nothing but unpriced tokens comes out at $0.00, which tells the user
@@ -174,9 +99,8 @@ function getAddressValue(addr) {
         // nor make it incomplete. Anything that is not a number at all is not
         // a holding this can price either, and is left to the same rule.
         if (!(tokenBal > 0)) continue;
-        const price = prices[token.address.toLowerCase()];
-        if (price) {
-            usd += tokenBal * price;
+        if (prices[token.symbol]) {
+            usd += tokenBal * prices[token.symbol];
         } else {
             partial = true;
         }

src/shared/state.js

@@ -125,14 +125,11 @@ function currentNetwork() {
     return networkById(state.networkId);
 }
 
-// `baseline` holds the persisted fields as this page held them when its last
-// loadState() finished, or when its last successful saveState() began.
-// takeStoredNetwork(), takeStoredTrackedTokens() and
-// takeStoredNetworkTrackedTokens() also write into it what this page has taken
-// from the stored record since then. `baseline` also lacks any
-// `balanceNotFetched` field that a balance refresh has deleted since
-// (clearBalanceNotFetched()). saveState() diffs the live state against
-// `baseline` to find only the fields THIS page changed since.
+// The persisted fields as this page held them when its last loadState()
+// finished, or when its last successful saveState() began, with any network
+// switch saved elsewhere that this page has taken since (takeStoredNetwork()).
+// saveState() diffs the live state against this to find only the fields THIS
+// page changed since.
 //
 // Deep-cloned, not a reference: callers mutate persisted objects and arrays
 // in place (state.wallets.push(...)), and a reference baseline would mutate
@@ -404,51 +401,6 @@ function mergeNetworkEndpoints(base, ours, theirs) {
     return mergeMapByKey(base, ours, theirs, mergeEndpointEntry);
 }
 
-// Merges one network's tracked tokens by contract address:
-//
-// - A token another page added or removed since this page's last save stays
-//   added or removed.
-// - A token that this page and `theirs` both hold keeps this page's record.
-// - The result holds one record per contract address.
-//
-// mergeListByIdentity() keeps records that share an identity, on purpose, for
-// wallets. A contract address names one token, so this keeps one record for it.
-// Without that, a token that `ours` and `theirs` each hold twice comes back four
-// times, and each later merge multiplies it again.
-//
-// `theirs` takes this page's records first. mergeListByIdentity() would
-// otherwise log an error for two different records of one token.
-function mergeTrackedTokens(base, ours, theirs) {
-    const contract = (token) => token.address.toLowerCase();
-    const oursByContract = new Map(
-        ours.map((token) => [contract(token), token]),
-    );
-    const merged = mergeListByIdentity(
-        base,
-        ours,
-        theirs.map((token) => oursByContract.get(contract(token)) || token),
-        contract,
-        (baseToken, ourToken) => ourToken,
-    );
-    const byContract = new Map(merged.map((token) => [contract(token), token]));
-    return [...byContract.values()];
-}
-
-// Returns a copy of `stored.networkTrackedTokens` for when this page has not yet
-// taken the switch in `stored`. `page` is this page's state. A token that this
-// page tracked or removed since its last save is tracked or removed in the list
-// of `page.networkId`, by contract address.
-function networkTrackedTokensWithChange(stored, page) {
-    return {
-        ...stored.networkTrackedTokens,
-        [page.networkId]: mergeTrackedTokens(
-            baseline.trackedTokens,
-            page.trackedTokens,
-            stored.networkTrackedTokens[page.networkId] || [],
-        ),
-    };
-}
-
 // Read-modify-write, merged per field, rather than one full-blob write.
 //
 // Every extension page (the toolbar popup, a dApp approval window) holds its
@@ -489,27 +441,16 @@ function networkTrackedTokensWithChange(stored, page) {
 // comment at mergeEndpointEntry() for why the collision this closes is
 // milder than the other two.
 //
-// `trackedTokens` is merged by contract address (mergeTrackedTokens()) when this
-// page has changed it, so a token another page added or removed since this
-// page's last save stays added or removed. A token both lists hold keeps this
-// page's record. Two saves differ:
-//
-// - When the stored record is on another network than this page's, a save keeps
-//   the stored `trackedTokens`. It merges this page's change into the list in
-//   `networkTrackedTokens` for this page's network, by contract address.
-// - A save that switches networks writes this page's list whole. A switch in
-//   Settings first merges that list by contract address
-//   (takeStoredTrackedTokens()).
-//
 // Every other persisted field stays a whole-field diff:
-// `fraudContracts`/`viewStack` are arrays of scalars with no per-element
-// identity to merge by; `networkTrackedTokens` is diffed whole like `networkId`,
-// which a network switch moves together with it; `tokenHolderCache` is a map
-// shaped like the ones above, but nothing in src/ ever writes an entry into it —
-// it is only ever reset wholesale to `{}` (applyChainSwitchFields()) — so there
-// is no in-place mutation for a whole-field diff to collide with; `viewData` is
-// this page's own UI scratch space, not data another page has any reason to
-// share membership of.
+// `trackedTokens`/`fraudContracts`/`viewStack` are arrays of scalars with no
+// per-element identity to merge by; `networkTrackedTokens` is diffed whole like
+// `trackedTokens` and `networkId`, the two fields a network switch moves
+// together with it; `tokenHolderCache` is a map shaped like the ones above,
+// but nothing in src/ ever writes an entry into it — it is only ever reset
+// wholesale to `{}` (applyChainSwitchFields()) — so there is no in-place
+// mutation for a whole-field diff to collide with; `viewData` is this page's
+// own UI scratch space, not data another page has any reason to share
+// membership of.
 //
 // This does not make two pages that both change the SAME leaf concurrently
 // safe: last write wins on that one leaf, same as before. What it removes
@@ -583,34 +524,6 @@ async function saveStateOnce(beforeWrite) {
             merged[key] = current[key];
         }
     }
-    // When the merged record names a network other than this page's, this page
-    // has not yet taken a switch saved elsewhere. This page's `trackedTokens`
-    // is then the list of this page's network. The stored record keeps the
-    // list of this page's network in `networkTrackedTokens`. So a token that
-    // this page added or removed since its last save is added to or removed
-    // from that stored list. The merged record keeps the stored `trackedTokens`
-    // (https://git.eeqj.de/sneak/AutistMask/issues/701).
-    if (merged.networkId !== current.networkId) {
-        merged.trackedTokens = fresh.trackedTokens;
-        merged.networkTrackedTokens = networkTrackedTokensWithChange(
-            fresh,
-            current,
-        );
-    } else if (
-        baseline !== null &&
-        baseline.networkId === current.networkId &&
-        !deepEqual(current.trackedTokens, baseline.trackedTokens)
-    ) {
-        // This page's network is the one it last saved on, and the stored
-        // record is on it too, so all three lists are of one network. This
-        // page's change goes into the stored list, and another page's add or
-        // removal stays (https://git.eeqj.de/sneak/AutistMask/issues/717).
-        merged.trackedTokens = mergeTrackedTokens(
-            baseline.trackedTokens,
-            current.trackedTokens,
-            fresh.trackedTokens,
-        );
-    }
     merged.hasWallet = Boolean(merged.wallets && merged.wallets.length > 0);
     // Stamped on every write, never merged or diffed: the record that goes to
     // storage is in THIS build's shape whatever shape it was read in, which is
@@ -678,10 +591,8 @@ function reportSaveFailure(err) {
 //
 // `beforeWrite`, when given, is called inside the lock with the stored record
 // as just read, before this page's state is compared against it. It may change
-// `state`, and this save writes that change. It may also change the stored
-// record. A field that this page did not change is then written as
-// `beforeWrite` left it. When it returns false, nothing is written; any other
-// return lets the save go ahead.
+// `state`, and this save writes that change. When it returns false, nothing is
+// written; any other return lets the save go ahead.
 function saveState(beforeWrite) {
     const turn = withLock("autistmask", () => saveStateOnce(beforeWrite));
     // Every failed save is reported, whether or not the caller awaited this
@@ -691,81 +602,15 @@ function saveState(beforeWrite) {
     return turn;
 }
 
-// Give this page the network switch held by `stored`, in `state` and in
-// `baseline` alike, as loadState() does with a whole record. `stored` is the
-// record that a save of this page has just read. followStoredSettings() in
-// src/popup/index.js and onChainSwitch() in src/shared/chainSwitch.js call this
-// from `beforeWrite`. The switch is then not this page's own change, even when
+// Give this page the network switch held by `stored`, a record a save of this
+// page has just read (followStoredSettings() in src/popup/index.js calls this
+// from `beforeWrite`), in `state` and in `baseline` alike, as loadState() does
+// with a whole record. The switch is then not this page's own change, even when
 // that save fails to write: a later switch back to the previous network still
 // differs from `baseline`, and is stored.
-//
-// A token that this page tracked or removed since its last save was tracked or
-// removed on this page's network before the switch. `state` keeps that change
-// in the list in `networkTrackedTokens` for that network, merged with the
-// stored list by contract address. `baseline` takes the stored list, so the
-// save stores the change (https://git.eeqj.de/sneak/AutistMask/issues/706).
 function takeStoredNetwork(stored) {
-    const networkTrackedTokens = networkTrackedTokensWithChange(
-        stored,
-        rawState,
-    );
     copyChainSwitchFields(rawState, stored);
     copyChainSwitchFields(baseline, structuredClone(stored));
-    rawState.networkTrackedTokens = networkTrackedTokens;
-}
-
-// Give this page the tracked tokens of `stored`, a record on this page's
-// network that a save of this page has just read (onChainSwitch() in
-// src/shared/chainSwitch.js calls this from `beforeWrite`):
-//
-// - A token that another page tracked or removed since this page's last save
-//   is tracked or removed in `state` too.
-// - A token that this page tracked or removed since then stays as this page
-//   has it.
-//
-// `baseline` takes the stored list, so the save stores the list in `state`
-// whenever the two differ.
-function takeStoredTrackedTokens(stored) {
-    rawState.trackedTokens = mergeTrackedTokens(
-        baseline.trackedTokens,
-        rawState.trackedTokens,
-        stored.trackedTokens,
-    );
-    baseline.trackedTokens = structuredClone(stored.trackedTokens);
-}
-
-// Give `state` and `baseline` each their own copy of the stored
-// `networkTrackedTokens`. `stored` is a record on this page's network that a
-// save of this page has just read. onChainSwitch() in
-// src/shared/chainSwitch.js calls this from `beforeWrite`.
-function takeStoredNetworkTrackedTokens(stored) {
-    rawState.networkTrackedTokens = structuredClone(
-        stored.networkTrackedTokens,
-    );
-    baseline.networkTrackedTokens = structuredClone(
-        stored.networkTrackedTokens,
-    );
-}
-
-// Deletes `balanceNotFetched` from each tracked token whose lowercased
-// contract address is in `addresses`. The field goes from `stored`, from
-// `state` and from `baseline` alike. `stored` is the record a save of this
-// page has just read (doRefreshAndRender() in src/popup/index.js calls this
-// from `beforeWrite`). So the deletion is not a change this page made to its
-// tracked tokens. Unless this page has changed its tracked tokens itself, the
-// save then writes the stored list with only the field gone.
-function clearBalanceNotFetched(stored, addresses) {
-    for (const list of [
-        stored.trackedTokens,
-        rawState.trackedTokens,
-        baseline.trackedTokens,
-    ]) {
-        for (const token of list) {
-            if (addresses.includes(token.address.toLowerCase())) {
-                delete token.balanceNotFetched;
-            }
-        }
-    }
 }
 
 // Rejects with StateUnusableError for a stored record this build cannot make
@@ -814,9 +659,6 @@ module.exports = {
     saveState,
     onSaveFailure,
     takeStoredNetwork,
-    takeStoredTrackedTokens,
-    takeStoredNetworkTrackedTokens,
-    clearBalanceNotFetched,
     loadState,
     currentAddress,
     currentNetwork,

src/shared/storedSettings.js

@@ -1,5 +1,5 @@
-// Reads "Use Blockscout", "Check recipients on Etherscan" or the active network
-// from the stored profile.
+// Reads "Use Blockscout" or "Check recipients on Etherscan" from the stored
+// profile.
 //
 // Before each request that sends the user's data to Blockscout or Etherscan, the
 // wallet reads that service's setting from storage. The wallet reads the setting
@@ -7,11 +7,6 @@
 // made, and an answer that lands after the setting went off is dropped. A page's
 // own copy of the setting is not used, because another page may have just
 // changed it.
-//
-// Before asking Blockscout for the transaction history, a screen remembers
-// which network is active. If another network is active on the page or in
-// storage when the answer lands, the screen drops the answer. A switch saved
-// elsewhere reaches storage first and the page later.
 
 const { storageGet } = require("./browserApi");
 const { normalizePersisted } = require("./persistedState");
@@ -29,15 +24,4 @@ async function storedSettingIsOn(name) {
     }
 }
 
-// Whether `networkId` is the active network in the stored profile. A failed
-// read counts as no.
-async function storedNetworkIs(networkId) {
-    try {
-        const { autistmask } = await storageGet("autistmask");
-        return normalizePersisted(autistmask).networkId === networkId;
-    } catch {
-        return false;
-    }
-}
-
-module.exports = { storedSettingIsOn, storedNetworkIs };
+module.exports = { storedSettingIsOn };

src/shared/symbolSpoof.js

@@ -19,8 +19,7 @@
 // them hid the other one's holders' money (issue #276).  Membership, not
 // equality, is therefore the question — but it is the same question, asked of
 // a table that can now state the truth.  Every address in a set is one the
-// wallet ships as a real token on Ethereum Mainnet.  On mainnet, a contract
-// outside the set is still a spoof.
+// wallet ships as a real token; a contract outside the set is still a spoof.
 //
 // The symbol is attacker-controlled — it is whatever the ERC-20 contract
 // returns — so the lookup is done on a normalized form (issue #260): the
@@ -28,7 +27,6 @@
 // since that is what the user acts on.
 
 const { KNOWN_SYMBOLS } = require("./tokenList");
-const { NETWORKS } = require("./networks");
 
 // Ethereum addresses are case-insensitive: EIP-55 mixed case is a checksum
 // over the address, not part of its identity.
@@ -95,24 +93,18 @@ function normalizeSymbol(symbol) {
 }
 
 // True when a token bearing `symbol` from contract `contractAddress` is
-// impersonating a known symbol. `chainId` is the chain id of the token's
-// network.
-//
-// The native asset's labels are known symbols on every network. The bundled
-// list's symbols are known symbols only on Ethereum Mainnet, because the list
-// holds mainnet contracts.
+// impersonating a known symbol.
 //
 // An empty contract address is the native asset, which is never a spoof:
 // this is what keeps the user's real ETH out of the rule, and it holds for
 // any symbol that becomes null-mapped later, not just for ETH.
-function isSpoofedSymbol(symbol, contractAddress, chainId) {
+function isSpoofedSymbol(symbol, contractAddress) {
     const contract = normalizeAddress(contractAddress);
     if (!contract) return false;
     const sym = normalizeSymbol(symbol);
     if (!KNOWN_SYMBOLS.has(sym)) return false;
     const legit = KNOWN_SYMBOLS.get(sym);
     if (legit === null) return true;
-    if (chainId !== NETWORKS.mainnet.chainId) return false;
     return !legit.has(contract);
 }
 

src/shared/tokenList.js

@@ -4,12 +4,12 @@
 // Addresses are EIP-55 checksummed.
 //
 // 511 tokens.
-//
-// Below the list, USD_PRICE_FEEDS gives the Chainlink USD price feed of each
-// token that has one.
 
+const { debugFetch } = require("./log");
 const { NETWORKS } = require("./networks");
 
+const COINDESK_API = "https://data-api.coindesk.com/index/cc/v1/latest/tick";
+
 const TOKENS = [
     {
         address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
@@ -3597,351 +3597,6 @@ const TOKENS = [
     },
 ];
 
-// Chainlink price feeds on Ethereum mainnet. Each feed is a contract whose
-// latestRoundData() returns a USD price and the time the price was written.
-// The fields of a feed:
-//
-//   - address: the feed's contract
-//   - heartbeat: the most seconds the feed goes without a new price
-//   - decimals: the number of decimal places in the price
-//
-// Each feed's address and heartbeat come from Chainlink's published list of
-// mainnet feeds. Each feed was checked on mainnet by reading its description()
-// and decimals().
-
-// The ETH/USD feed, which prices ether and WETH.
-const ETH_USD_FEED = {
-    address: "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419",
-    heartbeat: 3600,
-    decimals: 8,
-};
-
-// The USD feed of each token in TOKENS that has one, keyed by the token's
-// contract address as TOKENS spells it. A token is paired with its feed by its
-// address alone, so a token that copies a listed token's symbol gets no feed.
-const USD_PRICE_FEEDS = {
-    // WETH
-    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": ETH_USD_FEED,
-    // USDT
-    "0xdAC17F958D2ee523a2206206994597C13D831ec7": {
-        address: "0x3E7d1eAB13ad0104d2750B8863b489D65364e32D",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // BNB
-    "0xB8c77482e45F1F44dE1745F52C74426C631bDD52": {
-        address: "0x14e613AC84a31f709eadbdF89C6CC390fDc9540A",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // USDC
-    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": {
-        address: "0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6",
-        heartbeat: 82800,
-        decimals: 8,
-    },
-    // USDS
-    "0xdC035D45d973E3EC169d2276DDab16f1e407384F": {
-        address: "0xfF30586cD0F29eD462364C7e81375FC0C71219b1",
-        heartbeat: 82800,
-        decimals: 8,
-    },
-    // LINK
-    "0x514910771AF9Ca656af840dff83E8264EcF986CA": {
-        address: "0x2c1d072e956AFFC0D435Cb7AC38EF18d24d9127c",
-        heartbeat: 3600,
-        decimals: 8,
-    },
-    // USDE
-    "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3": {
-        address: "0xa569d910839Ae8865Da8F8e70FfFb0cBA869F961",
-        heartbeat: 82800,
-        decimals: 8,
-    },
-    // USD1
-    "0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d": {
-        address: "0xF0d9bb015Cd7BfAb877B7156146dc09Bf461370d",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // DAI
-    "0x6B175474E89094C44Da98b954EedeAC495271d0F": {
-        address: "0xAed0c38402a5d19df6E4c03F4E2DceD6e29c1ee9",
-        heartbeat: 3600,
-        decimals: 8,
-    },
-    // PYUSD
-    "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8": {
-        address: "0x8f1dF6D7F2db73eECE86a18b4381F4707b918FB1",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // WLFI
-    "0xdA5e1988097297dCdc1f90D4dFE7909e847CBeF6": {
-        address: "0x14E5FC91Ddb3f97C33013Cc9fA74F54062Ad1Aa1",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // UNI
-    "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984": {
-        address: "0x553303d460EE0afB37EdFf9bE42922D8FF63220e",
-        heartbeat: 3600,
-        decimals: 8,
-    },
-    // PAXG
-    "0x45804880De22913dAFE09f4980848ECE6EcbAf78": {
-        address: "0x9944D86CEB9160aF5C5feB251FD671923323f8C3",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // AAVE
-    "0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9": {
-        address: "0x547a514d5e3769680Ce22B2361c10Ea13619e8a9",
-        heartbeat: 3600,
-        decimals: 8,
-    },
-    // USDF
-    "0xFa2B947eEc368f42195f24F36d2aF29f7c24CeC2": {
-        address: "0xb177857a1799aA5F7fEb5799Fdf12CbE8fdF78B1",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // USDG
-    "0xe343167631d89B6Ffc58B88d6b7fB0228795491D": {
-        address: "0x14f0737d6b705259e521EA6E9E3506AC78dBd311",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // SKY
-    "0x56072C95FAA701256059aa122697B133aDEd9279": {
-        address: "0xee10fE5E7aa92dd7b136597449c3d5813cFC5F18",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // RLUSD
-    "0x8292Bb45bf1Ee4d140127049757C2E0fF06317eD": {
-        address: "0x26C46B7aD0012cA71F2298ada567dC9Af14E7f2A",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // USDTB
-    "0xC139190F447e929f090Edeb554D95AbB8b18aC1C": {
-        address: "0x66704DAD467A7cA508B3be15865D9B9F3E186c90",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // ARB
-    "0xB50721BCf8d664c30412Cfbc6cf7a15145234ad1": {
-        address: "0x31697852a68433DbCc2Ff612c516d69E3D9bd08F",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // USD0
-    "0x73A15FeD60Bf67631dC6cd7Bc5B6e8da8190aCF5": {
-        address: "0x7e891DEbD8FA0A4Cf6BE58Ddff5a8ca174FebDCB",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // GHO
-    "0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f": {
-        address: "0x3f12643D3f6f874d39C2a4c9f2Cd6f2DbAC877FC",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // TUSD
-    "0x0000000000085d4780B73119b644AE5ecd22b376": {
-        address: "0xec746eCF986E2927Abd291a2A1716c940100f8Ba",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // EURC
-    "0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c": {
-        address: "0x04F84020Fdf10d9ee64D1dcC2986EDF2F556DA11",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // FDUSD
-    "0xc5f0f7b66764F6ec8C8Dff7BA683102295E16409": {
-        address: "0xfAA9147190c2C2cc5B8387B4f49016bDB3380572",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // CRV
-    "0xD533a949740bb3306d119CC777fa900bA034cd52": {
-        address: "0xCd627aA160A6fA45Eb793D19Ef54f5062F20f33f",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // GRT
-    "0xc944E90C64B2c07662A292be6244BDf05Cda44a7": {
-        address: "0x86cF33a451dE9dc61a2862FD94FF4ad4Bd65A5d2",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // CRVUSD
-    "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E": {
-        address: "0xEEf0C605546958c1f899b6fB336C20671f9cD49F",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // FRAX, the Legacy Frax Dollar, priced by Chainlink's FRAX / USD feed
-    "0x853d955aCEf822Db058eb8505911ED77F175b99e": {
-        address: "0xB9E1E3A9feFf48998E45Fa90847ed4D467E8BcfD",
-        heartbeat: 3600,
-        decimals: 8,
-    },
-    // ENS
-    "0xC18360217D8F7Ab5e7c516566761Ea12Ce7F9D72": {
-        address: "0x5C00128d4d1c2F4f652C267d7bcdD7aC99C16E16",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // SAND
-    "0x3845badAde8e6dFF049820680d1F14bD3903a5d0": {
-        address: "0x35E3f7E558C04cE7eEE1629258EcbbA03B36Ec56",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // AUSD
-    "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a": {
-        address: "0xB00341502DfEA6Ced8A5786b4059d29dA5E4D1FD",
-        heartbeat: 86400,
-        decimals: 18,
-    },
-    // COMP
-    "0xc00e94Cb662C3520282E6f5717214004A7f26888": {
-        address: "0xdbd020CAeF83eFd542f4De03e3cF0C28A4428bd5",
-        heartbeat: 3600,
-        decimals: 8,
-    },
-    // XCN
-    "0xA2cd3D43c775978A96BdBf12d733D5A1ED94fb18": {
-        address: "0xeb988B77b94C186053282BfcD8B7ED55142D3cAB",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // CVX
-    "0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B": {
-        address: "0xd962fC30A72A84cE50161031391756Bf2876Af5D",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // IMX
-    "0xF57e7e7C23978C3cAEC3C3548E3D615c346e79fF": {
-        address: "0xBAEbEFc1D023c0feCcc047Bff42E75F15Ff213E6",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // 1INCH
-    "0x111111111117dC0aa78b770fA6A738034120C302": {
-        address: "0xc929ad75B72593967DE83E7F7Cda0493458261D9",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // SNX
-    "0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F": {
-        address: "0xDC3EA94CD0AC27d9A86C180091e7f78C683d3699",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // DOLA
-    "0x865377367054516e17014CcdED1e7d814EDC9ce4": {
-        address: "0xE33592594f72Cc7ec8a05788be8E8455746C3a32",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // FRXUSD
-    "0xCAcd6fd266aF91b8AeD52aCCc382b4e165586E29": {
-        address: "0x9B4a96210bc8D9D55b1908B465D8B0de68B7fF83",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // YFI
-    "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e": {
-        address: "0xA027702dbb89fbd58938e4324ac03B58d812b0E1",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // RSR
-    "0x320623b8E4fF03373931769A31Fc52A4E78B5d70": {
-        address: "0x759bBC1be8F90eE6457C44abc7d443842a976d02",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // ZRX
-    "0xE41d2489571d322189246DaFA5ebDe1F4699F498": {
-        address: "0x2885d15b8Af22648b98B122b22FDF4D2a56c6023",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // FRAX, formerly FXS, priced by Chainlink's FXS / USD feed
-    "0x3432B6A60D23Ca0dFCa7761B7ab56459D9C964D0": {
-        address: "0x6Ebc52C8C1089be9eB3945C4350B68B8E4C2233f",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // SXT
-    "0xE6Bfd33F52d82Ccb5b37E16D3dD81f9FFDAbB195": {
-        address: "0x2D27d9e1b74936D8E83c4BA118F09A4c4a897f62",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // SUSHI
-    "0x6B3595068778DD592e39A122f4f5a5cF09C90fE2": {
-        address: "0xCc70F09A6CC17553b2E31954cD36E4A2d89501f7",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // RPL
-    "0xD33526068D116cE69F19A9ee46F0bd304F21A51f": {
-        address: "0x4E155eD98aFE9034b7A5962f6C84c86d869daA9d",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // USDP
-    "0x8E870D67F660D95d5be530380D0eC0bd388289E1": {
-        address: "0x09023c0DA49Aaf8fc3fA3ADF34C6A7016D38D5e3",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // SPELL
-    "0x090185f2135308BaD17527004364eBcC2D37e5F6": {
-        address: "0x8c110B94C5f1d347fAcF5E1E938AB2db60E3c9a8",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // LUSD
-    "0x5f98805A4E8be255a32880FDeC7F6728C6568bA0": {
-        address: "0x3D7aE7E594f2f2091Ad8798313450130d0Aba3a0",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // STG
-    "0xAf5191B0De278C7286d6C7CC6ab6BB8A73bA2Cd6": {
-        address: "0x7A9f34a0Aa917D438e9b6E630067062B7F8f6f3d",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // KNC
-    "0xdeFA4e8a7bcBA345F687a2f1456F5Edd9CE97202": {
-        address: "0xf8fF43E991A81e6eC886a3D281A2C6cC19aE70Fc",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-    // MUSD (the other MUSD in TOKENS has no feed)
-    "0xacA92E438df0B2401fF60dA7E4337B687a2435DA": {
-        address: "0xc90E3460424fb8ea79775089E9053113FEE34Ed0",
-        heartbeat: 86400,
-        decimals: 8,
-    },
-};
-
-// Build a map of token address (lowercased) -> its USD price feed.
-const PRICE_FEED_BY_ADDRESS = new Map();
-for (const [address, feed] of Object.entries(USD_PRICE_FEEDS)) {
-    PRICE_FEED_BY_ADDRESS.set(address.toLowerCase(), feed);
-}
-
 // Return the top N tokens from the list.
 function getTopTokens(n) {
     return TOKENS.slice(0, n);
@@ -3953,15 +3608,6 @@ for (const t of TOKENS) {
     TOKEN_BY_ADDRESS.set(t.address.toLowerCase(), t);
 }
 
-// The bundled list's entry for the contract at `address` on the network with
-// chain id `chainId`, or null. The list holds Ethereum Mainnet contracts only.
-// A contract at the same address on another network is another token, so any
-// other chain id gets null.
-function bundledToken(address, chainId) {
-    if (chainId !== NETWORKS.mainnet.chainId) return null;
-    return TOKEN_BY_ADDRESS.get((address || "").toLowerCase()) || null;
-}
-
 // Build a map of symbol (uppercased) -> the set of contract addresses
 // (lowercased) that legitimately bear it.  Used for spoofed-symbol detection.
 // "ETH" maps to null: the native asset has no contract, so no contract may
@@ -3978,8 +3624,7 @@ function bundledToken(address, chainId) {
 // hides from the balance list, the history and the send selector at its own
 // address, so the user cannot spend it (issue #276).  Naming every address
 // that bears the symbol is the only shape that says what is true; it does not
-// loosen the rule.  On Ethereum Mainnet, a contract outside the set is still a
-// spoof.
+// loosen the rule, because a contract outside the set is still a spoof.
 const KNOWN_SYMBOLS = new Map();
 KNOWN_SYMBOLS.set("ETH", null);
 for (const network of Object.values(NETWORKS)) {
@@ -3998,15 +3643,41 @@ for (const t of TOKENS) {
     }
 }
 
-// Resolve a token symbol from multiple sources, never returning "?". The token
-// is a contract on the network with chain id `chainId`.
-function resolveSymbol(tokenAddress, tokenBalances, trackedTokens, chainId) {
+// Fetch USD prices for the top N tokens from CoinDesk.
+// Also always includes ETH. Returns { ETH: 1234.56, LINK: 8.60, ... }.
+// n must be <= 30 (API and sanity limit).
+async function getTopTokenPrices(n) {
+    if (n > 30) {
+        throw new Error("getTopTokenPrices: n must be <= 30, got " + n);
+    }
+    const symbols = ["ETH", ...TOKENS.slice(0, n).map((t) => t.symbol)];
+    const unique = [...new Set(symbols)];
+    const instruments = unique.map((s) => s + "-USD").join(",");
+    const url =
+        COINDESK_API +
+        "?market=cadli&instruments=" +
+        instruments +
+        "&apply_mapping=true";
+    const resp = await debugFetch(url);
+    const json = await resp.json();
+    const prices = {};
+    for (const [instrument, data] of Object.entries(json.Data || {})) {
+        const symbol = instrument.split("-")[0];
+        if (data.VALUE !== undefined) {
+            prices[symbol] = data.VALUE;
+        }
+    }
+    return prices;
+}
+
+// Resolve a token symbol from multiple sources, never returning "?".
+function resolveSymbol(tokenAddress, tokenBalances, trackedTokens) {
     const lower = (tokenAddress || "").toLowerCase();
     const tb = (tokenBalances || []).find(
         (t) => t.address.toLowerCase() === lower,
     );
     if (tb && tb.symbol) return tb.symbol;
-    const known = bundledToken(lower, chainId);
+    const known = TOKEN_BY_ADDRESS.get(lower);
     if (known && known.symbol) return known.symbol;
     const tracked = (trackedTokens || []).find(
         (t) => t.address.toLowerCase() === lower,
@@ -4019,10 +3690,7 @@ module.exports = {
     TOKENS,
     TOKEN_BY_ADDRESS,
     KNOWN_SYMBOLS,
-    ETH_USD_FEED,
-    USD_PRICE_FEEDS,
-    PRICE_FEED_BY_ADDRESS,
     getTopTokens,
-    bundledToken,
+    getTopTokenPrices,
     resolveSymbol,
 };

src/shared/transactions.js

@@ -8,7 +8,7 @@
 
 const { formatEther, formatUnits } = require("ethers");
 const { log, debugFetch } = require("./log");
-const { bundledToken } = require("./tokenList");
+const { TOKEN_BY_ADDRESS } = require("./tokenList");
 const { parseHoldersCount, isLowHolderCount } = require("./holders");
 const { isSpoofedSymbol } = require("./symbolSpoof");
 const { nativeCurrencyByChainId } = require("./networks");
@@ -47,7 +47,7 @@ function parseTx(tx, addrLower, chainId) {
     let direction = normalizeAddress(from) === addrLower ? "sent" : "received";
     let directionLabel = direction === "sent" ? "Sent" : "Received";
     if (toIsContract && method && method !== "transfer") {
-        const token = bundledToken(to, chainId);
+        const token = TOKEN_BY_ADDRESS.get(normalizeAddress(to));
         if (token) {
             symbol = token.symbol;
         }
@@ -317,10 +317,7 @@ function filterTransactions(txs, filters = {}) {
         const contract = normalizeAddress(tx.contractAddress);
 
         // Filter spoofed known symbols and record the fraud contract
-        if (
-            hideSpoofed &&
-            isSpoofedSymbol(tx.symbol, tx.contractAddress, tx.chainId)
-        ) {
+        if (hideSpoofed && isSpoofedSymbol(tx.symbol, tx.contractAddress)) {
             if (contract && !fraudSet.has(contract)) {
                 fraudSet.add(contract);
                 newFraud.push(contract);

src/shared/uniswap.js

@@ -452,8 +452,8 @@ const ADDRESS_THIS = "0x0000000000000000000000000000000000000002";
 // `decimals` is null when nothing knows this token's scale. It is not
 // defaulted to 18: the swap lines land on the same approval screen as the
 // ERC-20 line, and a scale guessed there is what showed a 1,000 USDT swap as
-// 0.000000000001. `sources` is as for resolveTokenDecimals(), which reads the
-// bundled list on Ethereum Mainnet, then the tracked tokens and the wallets.
+// 0.000000000001. `sources` is { trackedTokens, wallets }, shaped as they are
+// on `state`; resolveTokenDecimals() reads the bundled list, then those.
 //
 // A null `address` means UNDETERMINED — the calldata named no currency for
 // that side — and is refused rather than named. It is not native ETH: Uniswap
@@ -479,17 +479,6 @@ function tokenInfo(address, sources) {
     };
 }
 
-// The token of a Permit2 allowance or of a PERMIT2_TRANSFER_FROM, in the
-// shape tokenInfo() gives. Permit2 has no allowance of ETH and moves no ETH.
-// The zero address there reads as a token nothing knows: its amount in base
-// units, and the zero address as its token.
-function permit2TokenInfo(address, sources) {
-    if (address === "0x0000000000000000000000000000000000000000") {
-        return { symbol: null, decimals: null, address };
-    }
-    return tokenInfo(address, sources);
-}
-
 // A swap amount line. With a scale it is the token quantity; with none it is
 // the base-unit integer with the unknown scale stated, the same refusal the
 // ERC-20 amount line makes, so the screen has one way of saying it. `display`
@@ -508,18 +497,16 @@ function amountText(raw, info) {
 
 // The line giving a moved token, or the token of a permit, under `label`, in
 // the shape of the Token In line, so the screens show it as they show that
-// one. `info` is what tokenInfo() or permit2TokenInfo() gives for the token.
-// ETH has no address.
-function tokenMovedLine(label, info) {
+// one. ETH has no address.
+function tokenMovedLine(label, token, sources) {
+    const info = tokenInfo(token, sources);
     if (!present(info.address)) {
         return { label, value: info.symbol };
     }
     return {
         label,
-        value: info.symbol
-            ? info.symbol + " (" + info.address + ")"
-            : info.address,
-        address: info.address,
+        value: info.symbol ? info.symbol + " (" + token + ")" : token,
+        address: token,
         isToken: true,
     };
 }
@@ -988,9 +975,6 @@ function totalAmount(amounts) {
 // pays it of Token In as the step's amount in place of the rules' Amount, or
 // no amount when this decoder cannot tell what that is.
 //
-// `spent` lists the currency that each swap action spends, for each swap
-// action that this decoder could read.
-//
 // `takes` is every TAKE, TAKE_ALL and TAKE_PORTION, as the currency it takes
 // and its recipient as written, MSG_SENDER for a TAKE_ALL. TAKE_PORTION takes
 // a share of the currency, so it does not name the output side as TAKE does.
@@ -1166,8 +1150,6 @@ function decodeV4Swap(input) {
             }
         }
 
-        const spent = swaps.map((s) => s.tokenIn);
-
         // Rule 3.
         if (swapUndecoded) {
             return {
@@ -1175,7 +1157,6 @@ function decodeV4Swap(input) {
                 tokenOut: takeToken,
                 amountIn: null,
                 amountOutMin: null,
-                spent,
                 takes,
                 settledFromRouter,
                 paidByUser,
@@ -1186,6 +1167,7 @@ function decodeV4Swap(input) {
             };
         }
 
+        const spent = swaps.map((s) => s.tokenIn);
         const bought = swaps.map((s) => s.tokenOut);
 
         // Rules 1 and 2 for Token In.
@@ -1221,7 +1203,6 @@ function decodeV4Swap(input) {
             tokenOut,
             amountIn,
             amountOutMin,
-            spent,
             takes,
             settledFromRouter,
             paidByUser,
@@ -1246,9 +1227,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
     const release = routerRelease(toAddress, chainId);
     if (release === null) return null;
     const { commandTypeMask, commands, allowRevert } = release;
-    // The swap's tokens are contracts on the network with `chainId`, so they
-    // are named and scaled for that network.
-    const tokenSources = { ...sources, chainId };
     try {
         const parsed = ROUTER_IFACE.parseTransaction({ data });
         if (!parsed) return null;
@@ -1262,15 +1240,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         let inputEstablished = false;
         // Whether the user pays the step that set the input side: a V2 or V3
         // swap step with `payerIsUser` true, a V4 step the user pays some of
-        // its input currency (see paidByUser in the loop), or a WRAP_ETH,
-        // whose ETH comes from the transaction's value. A step that pays an
-        // ERC-20 token from the router takes none of that token from the
-        // sender.
+        // its input currency (see decodeV4Swap()), or a WRAP_ETH, whose ETH
+        // comes from the transaction's value. A step paid from the router
+        // takes nothing from the sender.
         let inputPaidByUser = false;
-        // The recipient of a WRAP_ETH that set the input side, as written,
-        // when it is not the router; otherwise null. That WRAP_ETH pays its
-        // WETH there, not to a swap step (see the Moved to lines).
-        let wrapEthRecipient = null;
         // The last PERMIT2_PERMIT this decoder read before a step set the
         // input side, or null (see permitStands after the loop).
         let permit = null;
@@ -1320,9 +1293,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         const commandNames = [];
 
         // THE INVARIANT: an amount and the token it is counted in always come
-        // from the same hop, or from hops that all spend that token or all buy
-        // it. A figure is never rendered against a token that did not supply
-        // it.
+        // from the same hop, or from hops that all spend that token. A figure
+        // is never rendered against a token that did not supply it.
         //
         // Both sides are therefore set as a PAIR — never field by field, and
         // never on truthiness. An address is never falsy once set but an
@@ -1366,24 +1338,18 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // What the steps take from the sender beyond the amount of the step
         // that sets the input side, as { token, amount }, in step order.
         // After the loop each joins the Amount line or gets lines of its own
-        // (see permitStands). A take with `atMost` set may take less than
-        // `amount`: it never joins the Amount line, and its line reads
-        // "Up to" and the amount. A take with a `recipient`, the ETH of a
-        // later WRAP_ETH that pays anyone but the router, never joins the
-        // Amount line either: its Moved to line names that recipient.
+        // (see permitStands).
         const userPaid = [];
         // A swap step the user pays for (`payerIsUser` true) takes `amount`
-        // of `token` from the sender, or at most that when `atMost` is set. A
-        // V2 exact-in of ALREADY_PAID takes nothing.
-        const addUserPaid = (token, amount, atMost = false) => {
-            if (amount !== ALREADY_PAID) {
-                userPaid.push({ token, amount, atMost });
-            }
+        // of `token` from the sender. A V2 exact-in of ALREADY_PAID takes
+        // nothing.
+        const addUserPaid = (token, amount) => {
+            if (amount !== ALREADY_PAID) userPaid.push({ token, amount });
         };
         // A step may take from the sender what this decoder did not read: a
         // V4 step whose input or one of whose SETTLEs or SETTLE_ALLs it
-        // cannot read; a V2 or V3 swap step, PERMIT2_TRANSFER_FROM or WRAP_ETH
-        // whose input it cannot read; a PERMIT2_TRANSFER_FROM_BATCH; an
+        // cannot read; a V2 or V3 swap step or PERMIT2_TRANSFER_FROM whose
+        // input it cannot read; a PERMIT2_TRANSFER_FROM_BATCH; an
         // EXECUTE_SUB_PLAN; and a step it fails on. It is recorded with a null
         // token and amount: one line says so, there is no Amount line, whose
         // figure may then be too low, and the amount of a permit after it
@@ -1441,10 +1407,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             const r = recipient.toLowerCase();
             return r === ADDRESS_THIS || r === toAddress.toLowerCase();
         };
-        const isSender = (recipient) => {
-            const r = recipient.toLowerCase();
-            return r === MSG_SENDER || r === sender;
-        };
         // A swap step or V4 SETTLE pays `amount` of `token` from the router's
         // own balance. CONTRACT_BALANCE pays all of it. Any other quantity
         // counts against the amount a WRAP_ETH stated, and the steps pay all
@@ -1477,73 +1439,17 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // A step pays `recipient`. `output` is the token a swap step or a V4
         // TAKE or TAKE_PORTION pays; other steps pass none.
         const addPayee = (recipient, output) => {
+            const r = recipient.toLowerCase();
             if (isRouter(recipient)) {
                 if (present(output)) {
                     heldByRouter.set(output.toLowerCase(), null);
                 }
-            } else if (isSender(recipient)) {
+            } else if (r === MSG_SENDER || r === sender) {
                 paidToSender = true;
             } else {
                 addPaidElsewhere(recipient);
             }
         };
-        // Each swap step that paid the sender some of the token it bought,
-        // as { step, token, amount, onlyToSender }:
-        // - `step` is the step's index;
-        // - `token` is that token;
-        // - `amount` is the step's stated minimum;
-        // - `onlyToSender` is whether the step paid all of that token to the
-        //   sender.
-        // A later step that spends that token takes the step off this list
-        // (see dropFromSum()).
-        let swapsPayingSender = [];
-        // The step being read spends `token`, so it may spend what an earlier
-        // swap step paid the sender. Each step on swapsPayingSender that
-        // bought `token` leaves the list. A step spends a token as follows:
-        // - a V2 or V3 swap step spends its input token;
-        // - a V4 step spends each token that one of its swap actions spends,
-        //   and each token that one of its SETTLEs or SETTLE_ALLs pays;
-        // - a PERMIT2_TRANSFER_FROM spends the token it moves.
-        const dropFromSum = (token) => {
-            swapsPayingSender = swapsPayingSender.filter(
-                (s) => !sameAddress(s.token, token),
-            );
-        };
-        // The minimum the output side shows for the swap step at `step`. The
-        // step buys `token` with the stated minimum `amount`, and pays
-        // `token` to `recipients`. The minimum is the step's own, unless this
-        // step and an earlier one on swapsPayingSender both pay `token` to
-        // the sender, as a route split across steps does. The minimum is then
-        // the total of all such steps' minimums. There is none when this
-        // decoder reads no minimum from one of them, or when one of them pays
-        // some of `token` elsewhere. There is also none when this decoder did
-        // not read one of them, or a step between them, in full (see
-        // stepsUnread).
-        const swapMinimum = (step, token, amount, recipients) => {
-            const toSender = recipients.filter(
-                (r) => present(r) && isSender(r),
-            );
-            if (toSender.length === 0) return amount;
-            swapsPayingSender.push({
-                step,
-                token,
-                amount,
-                onlyToSender: toSender.length === recipients.length,
-            });
-            const split = swapsPayingSender.filter((s) =>
-                sameAddress(s.token, token),
-            );
-            if (split.length < 2) return amount;
-            if (
-                split.some(
-                    (s) => !s.onlyToSender || typeof s.amount !== "bigint",
-                ) ||
-                stepsUnread.some((unread) => unread >= split[0].step)
-            ) {
-                return null;
-            }
-            return split.reduce((sum, s) => sum + s.amount, 0n);
-        };
         // A step that pays `token` to `recipient` is a hop, not a payout,
         // when the very next step is a V2 exact-in whose input is already
         // paid, whose path starts at `token`, and whose pair (see v2PairFor())
@@ -1685,7 +1591,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                                     : null,
                         });
                     }
-                    if (p) dropFromSum(p.token);
                 } else if (command === "BALANCE_CHECK_ERC20") {
                     const b = decodeBalanceCheck(inputs[i]);
                     if (!b) {
@@ -1708,13 +1613,13 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     } else {
                         // The router passes this check whenever the owner
                         // holds at least minBalance, so a zero one guarantees
-                        // nothing. A check the router lets fail guarantees
-                        // nothing either, so it is read as a zero one. A zero
-                        // check sets neither Token Out nor the minimum. Any
+                        // nothing and does not replace a minimum an earlier
+                        // step stated. A check the router lets fail guarantees
+                        // nothing either, so it is read as a zero one. Any
                         // other minBalance sets the output side as a swap
-                        // does. The check pays nobody.
+                        // does. It pays nobody.
                         const minBalance = allowedToFail ? 0n : b.minBalance;
-                        if (minBalance !== 0n) {
+                        if (!(minBalance === 0n && present(minOutput))) {
                             setOutput(i, b.token, minBalance, []);
                         }
                         keepsRouterWeth = true;
@@ -1728,18 +1633,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountIn);
                         }
-                        dropFromSum(s.tokenIn);
                         // Always update output: in multi-step swaps (V3 → V4),
-                        // the last swap step determines the final output
-                        // token. swapMinimum() gives the minimum.
-                        setOutput(
-                            i,
-                            s.tokenOut,
-                            swapMinimum(i, s.tokenOut, s.amountOutMin, [
-                                s.recipient,
-                            ]),
-                            [s.recipient],
-                        );
+                        // the last swap step determines the final output token
+                        // and minimum received amount.
+                        setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
                         if (!s.payerIsUser) {
                             spendFromRouter(s.tokenIn, s.amountIn);
                         }
@@ -1760,15 +1657,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountIn);
                         }
-                        dropFromSum(s.tokenIn);
-                        setOutput(
-                            i,
-                            s.tokenOut,
-                            swapMinimum(i, s.tokenOut, s.amountOutMin, [
-                                s.recipient,
-                            ]),
-                            [s.recipient],
-                        );
+                        setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
                         if (!s.payerIsUser) {
                             spendFromRouter(s.tokenIn, s.amountIn);
                         }
@@ -1800,15 +1689,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountInMax);
                         }
-                        dropFromSum(s.tokenIn);
-                        setOutput(
-                            i,
-                            s.tokenOut,
-                            swapMinimum(i, s.tokenOut, s.amountOut, [
-                                s.recipient,
-                            ]),
-                            [s.recipient],
-                        );
+                        setOutput(i, s.tokenOut, s.amountOut, [s.recipient]);
                         if (!isHop(i, s.tokenOut, s.recipient)) {
                             addPayee(s.recipient, s.tokenOut);
                         }
@@ -1906,28 +1787,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                                 w.amount,
                             );
                             inputPaidByUser = true;
-                            if (!isRouter(w.recipient)) {
-                                wrapEthRecipient = w.recipient;
-                            }
-                        } else if (
-                            w.amount > 0n &&
-                            w.amount !== CONTRACT_BALANCE
-                        ) {
-                            // The ETH of a stated amount comes from the
-                            // transaction's value. ETH an earlier step left in
-                            // the router may pay part of it, and the sender
-                            // then pays at most that amount. CONTRACT_BALANCE
-                            // states no amount to take.
-                            userPaid.push({
-                                token: "0x0000000000000000000000000000000000000000",
-                                amount: w.amount,
-                                atMost: heldByRouter.has(
-                                    "0x0000000000000000000000000000000000000000",
-                                ),
-                                recipient: isRouter(w.recipient)
-                                    ? null
-                                    : w.recipient,
-                            });
                         }
                         addPayee(w.recipient);
                         // CONTRACT_BALANCE wraps all the router's ETH.
@@ -1952,46 +1811,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     } else {
                         payeeUnread = true;
                         stepsUnread.push(i);
-                        spentUnread();
                     }
                 } else if (command === "V4_SWAP") {
                     const v4 = decodeV4Swap(inputs[i]);
                     const inputSetBefore = inputEstablished;
-                    // V4Router pays a SETTLE of ETH from the router's own
-                    // ETH, whichever payer the SETTLE names. The router holds
-                    // the transaction's value, and any ETH an earlier step
-                    // left it (see heldByRouter). So the user also pays a
-                    // SETTLE of ETH that names the router as payer. The user
-                    // pays all of its amount when the router holds no other
-                    // ETH, and up to its amount otherwise. CONTRACT_BALANCE
-                    // pays all the router holds, an amount the calldata does
-                    // not state.
-                    const routerHeldEth = heldByRouter.has(
-                        "0x0000000000000000000000000000000000000000",
-                    );
-                    const ethFromRouter = (v4?.settledFromRouter ?? [])
-                        .filter(
-                            (s) =>
-                                s.currency ===
-                                "0x0000000000000000000000000000000000000000",
-                        )
-                        .map((s) => ({
-                            currency: s.currency,
-                            amount:
-                                s.amount === CONTRACT_BALANCE ? null : s.amount,
-                        }));
-                    // What the user pays the step: what decodeV4Swap() says,
-                    // and the ETH of each SETTLE from the router of a known
-                    // amount when the router holds no other ETH.
-                    const paidByUser = v4
-                        ? v4.paidByUser.concat(
-                              routerHeldEth
-                                  ? []
-                                  : ethFromRouter.filter((s) =>
-                                        present(s.amount),
-                                    ),
-                          )
-                        : [];
                     if (v4) {
                         // Each SETTLE paid from the router spends the amount
                         // decodeV4Swap() says it pays.
@@ -2003,11 +1826,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                                 addPayee(t.recipient, t.currency);
                             }
                         }
-                        for (const token of v4.spent) dropFromSum(token);
-                        for (const s of v4.paidByUser) dropFromSum(s.currency);
-                        for (const s of v4.settledFromRouter) {
-                            dropFromSum(s.currency);
-                        }
                     }
                     if (!v4 || v4.recipientUnread) {
                         payeeUnread = true;
@@ -2027,10 +1845,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         commandNames[i] += " (could not be decoded)";
                     }
                     // The step's amount, if it sets the input side: what the
-                    // user pays it of its input currency, or, when the user
-                    // pays none of it, what its swap actions spend of it,
-                    // whoever pays that.
-                    const paidIn = paidByUser.find(
+                    // user pays it of its input currency (see
+                    // decodeV4Swap()), or, when the user pays none of it,
+                    // what its swap actions spend of it, whoever pays that.
+                    const paidIn = v4?.paidByUser.find(
                         (p) => p.currency === v4.tokenIn,
                     );
                     const amountIn = paidIn ? paidIn.amount : v4?.amountIn;
@@ -2056,12 +1874,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                             setInput(v4.tokenIn, amountIn);
                         }
                         outputToken = v4.tokenOut;
-                        minOutput = swapMinimum(
-                            i,
-                            v4.tokenOut,
-                            v4.amountOutMin,
-                            takeRecipients,
-                        );
+                        minOutput = v4.amountOutMin;
                         outputEstablished = true;
                         outputUnwrapped = false;
                         unwrapIntoRouterStep = null;
@@ -2089,33 +1902,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     // router still runs it.
                     const setInputHere = inputEstablished && !inputSetBefore;
                     if (setInputHere) inputPaidByUser = paidIn !== undefined;
-                    // ETH an earlier step left in the router may pay part of
-                    // the ETH that the user pays this step. The sender then
-                    // pays at most that amount.
-                    for (const p of paidByUser) {
+                    if (v4) {
+                        for (const p of v4.paidByUser) {
                             if (setInputHere && p === paidIn) continue;
-                        addUserPaid(
-                            p.currency,
-                            p.amount,
-                            routerHeldEth &&
-                                p.currency ===
-                                    "0x0000000000000000000000000000000000000000",
-                        );
-                    }
-                    // A SETTLE of ETH from the router that `paidByUser` leaves
-                    // out is a take of its own, even on the step that sets
-                    // the input side. Either this decoder does not know its
-                    // amount, or ETH an earlier step left in the router may
-                    // pay part of that amount (see userPaid).
-                    for (const p of ethFromRouter) {
-                        if (!present(p.amount)) {
-                            addUserPaid(p.currency, null);
-                        } else if (routerHeldEth) {
-                            userPaid.push({
-                                token: p.currency,
-                                amount: p.amount,
-                                atMost: true,
-                            });
+                            addUserPaid(p.currency, p.amount);
                         }
                     }
                     if (!v4 || v4.settleUnread) {
@@ -2223,10 +2013,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // The total is what the steps take of Token In: the amount of the
         // step that set the input side, with each later take of that token
         // added to it while both are quantities. A take that cannot be added,
-        // being of another token, coming after an amount that is not a
-        // quantity (a V4 open delta, ALREADY_PAID, or none stated), or having
-        // `atMost` or a `recipient` set, gets lines of its own. One whose
-        // amount is not known also leaves the total unknown, with no figure.
+        // being of another token or coming after an amount that is not a
+        // quantity (a V4 open delta, ALREADY_PAID, or none stated), gets
+        // lines of its own. One whose amount is not known also leaves the
+        // total unknown, with no figure.
         //
         // A PERMIT2_PERMIT names Token In only when its amount stands as the
         // Amount figure in place of the total, which it does only in the
@@ -2242,14 +2032,12 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // it may take more. A later permit or batch, or a later step this
         // decoder did not read, may raise what Permit2 lets the router take.
         // Every other PERMIT2_PERMIT leaves Token In and the Amount line as
-        // they read with no permit, and gets lines of its own below. A permit
-        // on the zero address never stands as the Amount figure, because
-        // Permit2 has no allowance of ETH. A step that may take from the
-        // sender what this decoder did not read leaves no figure, permit or
-        // not (see spentUnread()), and so do a permit or batch whose input it
-        // cannot read (see permitUnread()) and an allowance of Token In to
-        // another spender (see toAnotherSpender). An EXECUTE_SUB_PLAN step
-        // leaves both sides unknown (below).
+        // they read with no permit, and gets lines of its own below. A step
+        // that may take from the sender what this decoder did not read leaves
+        // no figure, permit or not (see spentUnread()), and so do a permit
+        // or batch whose input it cannot read (see permitUnread()) and an
+        // allowance of Token In to another spender (see toAnotherSpender). An
+        // EXECUTE_SUB_PLAN step leaves both sides unknown (below).
         const stepCommands = Array.from(
             commandsBytes,
             (b) => commands[b & commandTypeMask],
@@ -2259,27 +2047,24 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             stepCommands.filter((c) => c === "PERMIT2_PERMIT").length === 1 &&
             !stepCommands.includes("PERMIT2_PERMIT_BATCH") &&
             sameAddress(permit.spender, toAddress) &&
-            permit.token !== "0x0000000000000000000000000000000000000000" &&
             !permit.allowedToFail &&
             permit.beforeEveryTake &&
             !stepsUnread.some((step) => step > permit.step);
         // What the steps take that the Amount line does not give, as
-        // { token, amount, atMost, recipient }. A null token is a step this
-        // decoder did not read (see spentUnread()), or a token it does not
-        // know. `atMost` is as in `userPaid`. Only the take of a WRAP_ETH that
-        // pays elsewhere has a recipient (see wrapEthRecipient and userPaid).
+        // { token, amount }. A null token is a step this decoder did not read
+        // (see spentUnread()), or a token it does not know.
         const spentFromSender = [];
         let total = null;
-        // The takes from the sender that `total` adds up, each a quantity, in
-        // the shape of `spentFromSender`. When there is no Amount line, each
-        // gets lines of its own (see below). The amount of the step that set
-        // the input side counts in `total` whoever pays that step. That amount
-        // is among them only when the user pays the step (see inputPaidByUser).
+        // The takes from the sender that `total` adds up, each a quantity, as
+        // { token, amount }. When there is no Amount line, each gets lines of
+        // its own (see below). The amount of a step that set the input side
+        // and is paid from the router counts in `total` but is not among them.
         const inTotal = [];
         // Whether the step that set the input side counts as a take from the
         // sender, which may get lines of its own. The amount it stated counts
         // whoever pays it. Stating none, it counts only when the user pays it
-        // some of its input token.
+        // some of its input token: paid from the router, it takes nothing
+        // from the sender.
         const hasFirstTake =
             inputEstablished && (present(inputAmount) || inputPaidByUser);
         // The take of the step that set the input side, when the total
@@ -2288,11 +2073,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         if (!permitStands || sameAddress(inputToken, permit.token)) {
             total = inputAmount;
             if (typeof inputAmount === "bigint" && inputPaidByUser) {
-                inTotal.push({
-                    token: inputToken,
-                    amount: inputAmount,
-                    recipient: wrapEthRecipient,
-                });
+                inTotal.push({ token: inputToken, amount: inputAmount });
             }
             if (hasFirstTake && !present(inputAmount)) {
                 firstTakeUnstated = { token: inputToken, amount: null };
@@ -2300,11 +2081,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         } else if (hasFirstTake) {
             // The step that set the input side spent a token other than the
             // permit's, or one not known, so its amount gets lines of its own.
-            spentFromSender.push({
-                token: inputToken,
-                amount: inputAmount,
-                recipient: wrapEthRecipient,
-            });
+            spentFromSender.push({ token: inputToken, amount: inputAmount });
         }
         if (permitStands) inputToken = permit.token;
         for (const t of userPaid) {
@@ -2313,9 +2090,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             if (
                 ofTokenIn &&
                 typeof total === "bigint" &&
-                typeof t.amount === "bigint" &&
-                !t.atMost &&
-                !present(t.recipient)
+                typeof t.amount === "bigint"
             ) {
                 total += t.amount;
                 inTotal.push(t);
@@ -2364,11 +2139,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // Any other output keeps its own token and figure: a swap that pays
         // its WETH to the user and then unwraps receives WETH, and one that
         // buys USDC and then unwraps the WETH it did not spend receives USDC.
-        const inInfo = tokenInfo(inputToken, tokenSources);
+        const inInfo = tokenInfo(inputToken, sources);
         const outInfo =
             outputUnwrapped || (hasUnwrapWeth && !outputEstablished)
                 ? { symbol: "ETH", decimals: 18, address: null }
-                : tokenInfo(outputToken, tokenSources);
+                : tokenInfo(outputToken, sources);
 
         const inSymbol = inInfo.symbol;
         const outSymbol = outInfo.symbol;
@@ -2418,9 +2193,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // V2's already-paid zero, neither of which is a quantity at all (see
         // OPEN_DELTA and ALREADY_PAID), and an unbounded permit. Those two
         // tests come first — the sentinels are not bigints and cannot be
-        // compared with one. `atMost` marks an amount that is only the most a
-        // take may be (see userPaid).
-        const spentText = (amount, info, atMost) => {
+        // compared with one.
+        const spentText = (amount, info) => {
             if (amount === OPEN_DELTA) {
                 return { raw: OPEN_DELTA_AMOUNT, display: OPEN_DELTA_AMOUNT };
             }
@@ -2433,7 +2207,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             if (amount >= MAX_UINT160) {
                 return { raw: "Unlimited", display: "Unlimited" };
             }
-            if (hasV2OrV3ExactOut || atMost) {
+            if (hasV2OrV3ExactOut) {
                 // A V2 or V3 exact-out swap spends at most this figure,
                 // whichever steps gave it (an amountInMax, the WRAP_ETH of a
                 // swap paid in ETH, a permit, or several steps' total), so it
@@ -2460,19 +2234,17 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // A null token in `spentFromSender`, a step this decoder did not read
         // or a token it does not know, and an allowance to another spender
         // that may be of Token In, leave no Amount figure, which may then be
-        // too low. An allowance of the zero address is never one of Token In,
-        // because Permit2 has no allowance of ETH. With no Amount line, each
-        // take the total adds up gets lines of its own, first, so that every
-        // amount this decoder read is shown.
+        // too low. With no Amount line, each take the total adds up gets
+        // lines of its own, first, so that every amount this decoder read is
+        // shown.
         if (
             present(inputAmount) &&
             spentFromSender.every((s) => present(s.token)) &&
             toAnotherSpender.every(
                 (p) =>
-                    p.token === "0x0000000000000000000000000000000000000000" ||
-                    (present(p.token) &&
+                    present(p.token) &&
                     present(inputToken) &&
-                        !sameAddress(p.token, inputToken)),
+                    !sameAddress(p.token, inputToken),
             )
         ) {
             const amount = spentText(inputAmount, inInfo);
@@ -2488,53 +2260,32 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // What steps take from the sender beyond the Amount line, in the shape
         // of the lines below for a PERMIT2_TRANSFER_FROM. An amount this
         // decoder does not know is said so, and a step it did not read gets
-        // that one line alone. A take with no recipient goes to the swap step
-        // that spends it. A take with a recipient goes to that recipient;
-        // `MSG_SENDER` means the sender.
+        // that one line alone.
         for (const s of spentFromSender) {
             details.push({
                 label: "Moved from the sender",
                 value: present(s.amount)
-                    ? spentText(
-                          s.amount,
-                          tokenInfo(s.token, tokenSources),
-                          s.atMost,
-                      ).display
+                    ? spentText(s.amount, tokenInfo(s.token, sources)).display
                     : UNDECODED_CURRENCY,
             });
             if (present(s.token)) {
-                details.push(
-                    tokenMovedLine(
-                        "Token moved",
-                        tokenInfo(s.token, tokenSources),
-                    ),
-                );
-                if (!present(s.recipient)) {
+                details.push(tokenMovedLine("Token moved", s.token, sources));
                 details.push({
                     label: "Moved to",
                     value: "The swap step that spends it",
                 });
-                } else if (s.recipient.toLowerCase() === MSG_SENDER) {
-                    details.push({ label: "Moved to", value: "The sender" });
-                } else {
-                    details.push({
-                        label: "Moved to",
-                        value: s.recipient,
-                        address: s.recipient,
-                    });
-                }
             }
         }
 
         // What each PERMIT2_TRANSFER_FROM moves: its amount, its token and
         // where it goes, an address on a line of its own.
         for (const m of movedFromSender) {
-            const info = permit2TokenInfo(m.token, tokenSources);
             details.push({
                 label: "Moved from the sender",
-                value: amountText(m.amount, info).display,
+                value: amountText(m.amount, tokenInfo(m.token, sources))
+                    .display,
             });
-            details.push(tokenMovedLine("Token moved", info));
+            details.push(tokenMovedLine("Token moved", m.token, sources));
             details.push(
                 present(m.to)
                     ? { label: "Moved to", value: m.to }
@@ -2564,15 +2315,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 });
                 continue;
             }
-            const info = permit2TokenInfo(p.token, tokenSources);
             details.push({
                 label: "Permit2 allowance",
                 value:
                     p.amount >= MAX_UINT160
                         ? "Unlimited"
-                        : amountText(p.amount, info).display,
+                        : amountText(p.amount, tokenInfo(p.token, sources))
+                              .display,
             });
-            details.push(tokenMovedLine("Allowance token", info));
+            details.push(tokenMovedLine("Allowance token", p.token, sources));
             details.push({
                 label: "Allowance spender",
                 value: p.spender,
@@ -2630,7 +2381,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             paidTo.push({ label: "Paid to", value: PAID_TO_BRIDGE });
         }
         for (const m of movedIntoRouter) {
-            const info = permit2TokenInfo(m.token, tokenSources);
+            const info = tokenInfo(m.token, sources);
             paidTo.push({
                 label: "Paid to",
                 value:
@@ -2638,7 +2389,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     amountText(m.amount, info).display +
                     " from the sender (later steps may not spend all of it)",
             });
-            paidTo.push(tokenMovedLine("Token moved into the router", info));
+            paidTo.push(
+                tokenMovedLine("Token moved into the router", m.token, sources),
+            );
         }
         if (outputHeld) {
             paidTo.push({ label: "Paid to", value: STAYS_IN_ROUTER });
@@ -2655,7 +2408,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             paidTo.push(
                 tokenMovedLine(
                     "Token moved into the router",
-                    tokenInfo(getAddress(token), tokenSources),
+                    getAddress(token),
+                    sources,
                 ),
             );
         }

tests/addTokenLateAnswer.test.js

@@ -1,260 +0,0 @@
-// A contract lookup on AddToken can answer after the user has left AddToken.
-// The token is still added, and the screen the user is on does not change
-// (https://git.eeqj.de/sneak/AutistMask/issues/603). An answer while AddToken
-// still shows goes to AddressDetail. On either add-token screen, an answer for a
-// token tracked while the lookup waited tracks nothing
-// (https://git.eeqj.de/sneak/AutistMask/issues/727). A second click on a "Top
-// tokens:" button tracks nothing
-// (https://git.eeqj.de/sneak/AutistMask/issues/729). Driven through the real
-// popup over a stored profile.
-
-const {
-    bootPopup,
-    cleanupPopup,
-    unversionedValidProfile,
-    TOKEN_ADDRESS,
-} = require("./support/popupBoot");
-
-const TOKEN = {
-    address: TOKEN_ADDRESS,
-    symbol: "TST",
-    decimals: 18,
-    name: "Test Token",
-    balanceNotFetched: true,
-};
-
-// A second contract address, typed after AddToken was opened again.
-const OTHER_TOKEN_ADDRESS = "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
-
-afterEach(() => {
-    cleanupPopup();
-});
-
-// The popup reopened onto AddressDetail, then AddToken opened from it with
-// TOKEN's contract address typed in.
-async function openAddToken() {
-    const boot = await bootPopup(
-        unversionedValidProfile({
-            currentView: "address",
-            selectedWallet: 0,
-            selectedAddress: 0,
-        }),
-    );
-    expect(boot.pageErrors).toEqual([]);
-    await boot.click("btn-add-token");
-    expect(boot.visibleViews()).toEqual(["add-token"]);
-    boot.node("add-token-address").value = TOKEN.address;
-    return boot;
-}
-
-// Presses `button` with a contract lookup that answers only when the function
-// returned here is called. That function waits for the add to finish.
-function addWithPendingLookup(boot, button = "btn-add-token-confirm") {
-    const { lookupTokenInfo } = require("../src/shared/balances");
-    let answer;
-    lookupTokenInfo.mockImplementationOnce(
-        () =>
-            new Promise((resolve) => {
-                answer = resolve;
-            }),
-    );
-    const adding = boot.click(button);
-    return async () => {
-        answer({
-            symbol: TOKEN.symbol,
-            decimals: TOKEN.decimals,
-            name: TOKEN.name,
-        });
-        await adding;
-    };
-}
-
-test("an answer after the user opened Settings adds the token and Settings stays", async () => {
-    const boot = await openAddToken();
-    const answerLookup = addWithPendingLookup(boot);
-    await boot.click("btn-settings");
-    expect(boot.visibleViews()).toEqual(["settings"]);
-
-    await answerLookup();
-    expect(boot.visibleViews()).toEqual(["settings"]);
-    expect(boot.storage.read("autistmask").trackedTokens).toEqual([TOKEN]);
-});
-
-test("Back from Settings onto AddToken after the lookup answered shows no lookup status", async () => {
-    const boot = await openAddToken();
-    const answerLookup = addWithPendingLookup(boot);
-    expect(boot.text("add-token-info")).toBe("Looking up token...");
-    await boot.click("btn-settings");
-    await answerLookup();
-
-    await boot.click("btn-settings-back");
-    expect(boot.visibleViews()).toEqual(["add-token"]);
-    expect(boot.text("add-token-info")).toBe("");
-    expect(boot.node("add-token-info").style.visibility).toBe("hidden");
-});
-
-test("an answer after AddToken was opened again adds the token and leaves AddToken and its status line as they are", async () => {
-    const boot = await openAddToken();
-    const answerFirstLookup = addWithPendingLookup(boot);
-    await boot.click("btn-add-token-back");
-    await boot.click("btn-add-token");
-    expect(boot.visibleViews()).toEqual(["add-token"]);
-    boot.node("add-token-address").value = OTHER_TOKEN_ADDRESS;
-    // The second lookup is never answered.
-    addWithPendingLookup(boot);
-
-    await answerFirstLookup();
-    expect(boot.visibleViews()).toEqual(["add-token"]);
-    expect(boot.text("add-token-info")).toBe("Looking up token...");
-    expect(boot.storage.read("autistmask").trackedTokens).toEqual([TOKEN]);
-});
-
-test("a lookup that fails after AddToken was opened again leaves the status line as it is", async () => {
-    const boot = await openAddToken();
-    const { lookupTokenInfo } = require("../src/shared/balances");
-    let failFirstLookup;
-    lookupTokenInfo.mockImplementationOnce(
-        () =>
-            new Promise((_, reject) => {
-                failFirstLookup = reject;
-            }),
-    );
-    const firstAdd = boot.click("btn-add-token-confirm");
-    await boot.click("btn-add-token-back");
-    await boot.click("btn-add-token");
-    boot.node("add-token-address").value = OTHER_TOKEN_ADDRESS;
-    // The second lookup is never answered.
-    addWithPendingLookup(boot);
-
-    failFirstLookup(new Error("lookup failed"));
-    await firstAdd;
-    expect(boot.text("add-token-info")).toBe("Looking up token...");
-});
-
-test("an answer while AddToken still shows goes to AddressDetail with the token listed", async () => {
-    const boot = await openAddToken();
-    const answerLookup = addWithPendingLookup(boot);
-
-    await answerLookup();
-    expect(boot.visibleViews()).toEqual(["address"]);
-    expect(boot.node("address-balances").innerHTML).toContain("TST");
-    expect(boot.storage.read("autistmask").trackedTokens).toEqual([TOKEN]);
-});
-
-test("an answer for a token tracked after AddToken was opened again leaves the status line as it is", async () => {
-    const boot = await openAddToken();
-    const answerFirstLookup = addWithPendingLookup(boot);
-    await boot.click("btn-add-token-back");
-    await boot.click("btn-add-token");
-    boot.node("add-token-address").value = OTHER_TOKEN_ADDRESS;
-    // The second lookup is never answered.
-    addWithPendingLookup(boot);
-    require("../src/popup/views/helpers").trackToken(TOKEN);
-
-    await answerFirstLookup();
-    expect(boot.text("flash-msg")).toBe("TST is already being tracked.");
-    expect(boot.text("add-token-info")).toBe("Looking up token...");
-});
-
-// Each screen is opened from AddressDetail by the buttons named, in order.
-describe.each([
-    [
-        "AddToken",
-        ["btn-add-token"],
-        "add-token-address",
-        "btn-add-token-confirm",
-        "add-token-info",
-        "TST is already being tracked.",
-    ],
-    [
-        "SettingsAddToken",
-        ["btn-settings", "btn-settings-add-token"],
-        "settings-addtoken-address",
-        "btn-settings-addtoken-manual",
-        "settings-addtoken-info",
-        "Already tracked.",
-    ],
-])("%s", (_, opening, field, button, statusLine, alreadyTrackedFlash) => {
-    // The screen open with TOKEN's contract address typed in.
-    async function openScreen() {
-        const boot = await bootPopup(
-            unversionedValidProfile({
-                currentView: "address",
-                selectedWallet: 0,
-                selectedAddress: 0,
-            }),
-        );
-        expect(boot.pageErrors).toEqual([]);
-        for (const id of opening) await boot.click(id);
-        boot.node(field).value = TOKEN.address;
-        return boot;
-    }
-
-    test("a second click on Add while the lookup waits tracks the token once", async () => {
-        const boot = await openScreen();
-        const answerFirstClick = addWithPendingLookup(boot, button);
-        const answerSecondClick = addWithPendingLookup(boot, button);
-
-        await answerFirstClick();
-        await answerSecondClick();
-        expect(boot.text("flash-msg")).toBe(alreadyTrackedFlash);
-        expect(boot.storage.read("autistmask").trackedTokens).toEqual([TOKEN]);
-        const { state } = require("../src/shared/state");
-        expect(state.trackedTokens).toEqual([TOKEN]);
-    });
-
-    test("an answer for a token tracked while the lookup waited clears the status line", async () => {
-        const boot = await openScreen();
-        const answerLookup = addWithPendingLookup(boot, button);
-        expect(boot.text(statusLine)).toBe("Looking up token...");
-        require("../src/popup/views/helpers").trackToken(TOKEN);
-
-        await answerLookup();
-        expect(boot.text("flash-msg")).toBe(alreadyTrackedFlash);
-        expect(boot.text(statusLine)).toBe("");
-        expect(boot.node(statusLine).style.visibility).toBe("hidden");
-        const { state } = require("../src/shared/state");
-        expect(state.trackedTokens).toEqual([TOKEN]);
-    });
-});
-
-test('a double click on a "Top tokens:" button tracks the token once', async () => {
-    const boot = await bootPopup(
-        unversionedValidProfile({
-            currentView: "address",
-            selectedWallet: 0,
-            selectedAddress: 0,
-        }),
-    );
-    expect(boot.pageErrors).toEqual([]);
-    // The page stub does not turn the markup the screen draws into elements.
-    // So the list hands the screen a stand-in for TOKEN's button.
-    let press;
-    boot.node("settings-addtoken-top10").querySelectorAll = () => [
-        {
-            dataset: {
-                address: TOKEN.address,
-                symbol: TOKEN.symbol,
-                decimals: String(TOKEN.decimals),
-                name: TOKEN.name,
-            },
-            addEventListener: (name, fn) => {
-                press = fn;
-            },
-        },
-    ];
-    await boot.click("btn-settings");
-    await boot.click("btn-settings-add-token");
-
-    const firstClick = press();
-    const secondClick = press();
-    const { state } = require("../src/shared/state");
-    expect(state.trackedTokens).toEqual([TOKEN]);
-    // Read before the first click's save ends, when "Added TST" replaces it.
-    expect(boot.text("flash-msg")).toBe("Already tracked.");
-
-    await Promise.all([firstClick, secondClick]);
-    await boot.settle();
-    expect(state.trackedTokens).toEqual([TOKEN]);
-    expect(boot.storage.read("autistmask").trackedTokens).toEqual([TOKEN]);
-});

tests/addedTokenBalance.test.js

@@ -1,458 +0,0 @@
-// After "Add" on AddToken, AddressDetail lists the new token. Its line reads
-// `quantity unknown`, not 0.0000, until a balance refresh has read the token's
-// balance at every address, even if the popup closes and opens again
-// meanwhile. A token added on SettingsAddToken reads the same wherever it is
-// listed. A refresh that returns draws the balances on AddressDetail or
-// AddressToken again, so the fetched balance shows without the screen being
-// reopened (https://git.eeqj.de/sneak/AutistMask/issues/516).
-//
-// The tracked token's record carries `balanceNotFetched` until a refresh has
-// read the token's balance. Removing the token removes that record. A network
-// switch keeps each network's records apart. A refresh takes the field off the
-// stored record's tokens and keeps another page's changes to the stored list.
-//
-// Driven through the real popup over a stored profile on Ethereum Mainnet,
-// with "Show tracked tokens with zero balance" on, as it is by default.
-
-const {
-    bootPopup,
-    cleanupPopup,
-    unversionedValidProfile,
-} = require("./support/popupBoot");
-
-// Tracked by nobody until a test adds it.
-const NEW_TOKEN = "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
-
-// A holding of a million NEW_TOKEN, as refreshBalances() stores it.
-const MILLION = {
-    address: NEW_TOKEN,
-    name: "New Token",
-    symbol: "NEW",
-    decimals: 18,
-    balance: "1000000.0",
-    holders: 3,
-};
-
-// NEW_TOKEN as "Add" on AddToken tracks it, once a refresh has read its
-// balance.
-const NEW_TRACKED = {
-    address: NEW_TOKEN,
-    symbol: "NEW",
-    name: "New Token",
-    decimals: 18,
-};
-
-// A token that another popup page tracks.
-const OTHER_TOKEN = {
-    address: "0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
-    symbol: "OTH",
-    name: "Other Token",
-    decimals: 18,
-};
-
-afterEach(() => {
-    cleanupPopup();
-});
-
-// The popup reopened onto AddressDetail for the one address.
-function bootOnAddress(extra) {
-    return bootPopup(
-        unversionedValidProfile({
-            currentView: "address",
-            selectedWallet: 0,
-            selectedAddress: 0,
-            ...extra,
-        }),
-    );
-}
-
-// Holds the next balance refresh open. The returned function lets it finish
-// with the address's ETH balance at 2 and `tokenBalances` as its token
-// entries, having read the balance of every token tracked when it started.
-// Given null, it finishes having read no token's balance, as when every
-// balanceOf fails, and leaves the token entries as they were.
-function holdNextRefresh(page) {
-    const { refreshBalances } = require("../src/shared/balances");
-    let release;
-    refreshBalances.mockImplementationOnce(
-        async (wallets, rpcUrl, explorerUrl, trackedTokens) => {
-            const read = trackedTokens.map((t) => t.address.toLowerCase());
-            const tokenBalances = await new Promise((resolve) => {
-                release = resolve;
-            });
-            wallets[0].addresses[0].balance = "2.0";
-            if (tokenBalances === null) return [];
-            wallets[0].addresses[0].tokenBalances = tokenBalances;
-            return read;
-        },
-    );
-    return async (tokenBalances) => {
-        release(tokenBalances);
-        await page.settle();
-    };
-}
-
-// Runs the ten-second refresh to the end, finishing it as holdNextRefresh()
-// does with `tokenBalances`.
-async function refreshOnce(page, tokenBalances) {
-    const finish = holdNextRefresh(page);
-    const ticking = page.tick();
-    await page.settle();
-    await finish(tokenBalances);
-    await ticking;
-}
-
-// "+ Token", NEW_TOKEN typed in, and "Add", with the contract lookup
-// answering at once.
-async function addNewToken(page) {
-    const { lookupTokenInfo } = require("../src/shared/balances");
-    lookupTokenInfo.mockResolvedValueOnce({
-        symbol: "NEW",
-        decimals: 18,
-        name: "New Token",
-    });
-    await page.click("btn-add-token");
-    page.node("add-token-address").value = NEW_TOKEN;
-    await page.click("btn-add-token-confirm");
-}
-
-// Settings' "+ Add token", NEW_TOKEN typed in, and "Add", with the contract
-// lookup answering at once. It ends on SettingsAddToken.
-async function addOnSettingsAddToken(page) {
-    const { lookupTokenInfo } = require("../src/shared/balances");
-    lookupTokenInfo.mockResolvedValueOnce({
-        symbol: "NEW",
-        decimals: 18,
-        name: "New Token",
-    });
-    await page.click("btn-settings-add-token");
-    page.node("settings-addtoken-address").value = NEW_TOKEN;
-    await page.click("btn-settings-addtoken-manual");
-}
-
-// The "[x]" button Settings draws beside the first tracked token. The page
-// stub does not turn the markup Settings draws into elements. So the list
-// hands Settings a stand-in for that button each time it is drawn, and
-// `press()` presses the last one drawn. Call it before Settings opens.
-function firstRemoveButton(page) {
-    const button = { press: null };
-    page.node("settings-tracked-tokens").querySelectorAll = () => [
-        {
-            dataset: { idx: "0" },
-            addEventListener: (name, fn) => {
-                button.press = fn;
-            },
-        },
-    ];
-    return button;
-}
-
-// Picks `networkId` in the Settings network selector, as the user does.
-async function chooseNetwork(page, networkId) {
-    const select = page.node("settings-network");
-    select.value = networkId;
-    for (const fn of select.listeners.change) await fn();
-    await page.settle();
-}
-
-// Another popup page saves `trackedTokens` as the tracked token list. This
-// page is not told of the write.
-function anotherPageTracks(page, trackedTokens) {
-    page.storage.write("autistmask", {
-        ...page.storage.read("autistmask"),
-        trackedTokens,
-    });
-}
-
-// NEW_TOKEN's row in the balance list in element `id`, AddressDetail's unless
-// another is named, as markup.
-function newTokenRow(page, id = "address-balances") {
-    return page
-        .node(id)
-        .innerHTML.split("<div ")
-        .find((row) =>
-            row.includes('data-token="' + NEW_TOKEN.toLowerCase() + '"'),
-        );
-}
-
-// AddressDetail for the one address opened from Home, as its `[info]` button
-// does.
-async function openAddress(page) {
-    const { state } = require("../src/shared/state");
-    state.selectedWallet = 0;
-    state.selectedAddress = 0;
-    require("../src/popup/views/helpers").pushCurrentView();
-    require("../src/popup/views/addressDetail").show();
-    await page.settle();
-}
-
-// AddressToken for `token` opened from AddressDetail, as tapping the token's
-// row there does.
-async function openToken(page, token) {
-    const { state } = require("../src/shared/state");
-    state.selectedToken = token;
-    require("../src/popup/views/helpers").pushCurrentView();
-    require("../src/popup/views/addressToken").show();
-    await page.settle();
-}
-
-test("until the refresh Add started returns, the new token's line reads quantity unknown", async () => {
-    const page = await bootOnAddress();
-    expect(page.pageErrors).toEqual([]);
-    const finish = holdNextRefresh(page);
-
-    await addNewToken(page);
-
-    expect(page.visibleViews()).toEqual(["address"]);
-    const row = newTokenRow(page);
-    expect(row).toContain("quantity unknown");
-    expect(row).not.toContain("0.0000");
-    await finish([MILLION]);
-});
-
-test("once that refresh returns, AddressDetail shows the fetched balance without being reopened", async () => {
-    const page = await bootOnAddress();
-    const finish = holdNextRefresh(page);
-    await addNewToken(page);
-    // Stands for the transactions on the screen, which only show() replaces.
-    page.node("tx-list").innerHTML = "transactions on the screen";
-
-    await finish([MILLION]);
-
-    expect(page.visibleViews()).toEqual(["address"]);
-    expect(newTokenRow(page)).toContain("1000000.0000");
-    // Only the balances are drawn again, not the transaction list.
-    expect(page.node("tx-list").innerHTML).toBe("transactions on the screen");
-});
-
-test("a refresh already running when the token is added does not count as reading its balance", async () => {
-    const page = await bootOnAddress();
-    const finishRunning = holdNextRefresh(page);
-    const ticking = page.tick();
-    await page.settle();
-
-    await addNewToken(page);
-    await finishRunning([]);
-    await ticking;
-
-    expect(newTokenRow(page)).toContain("quantity unknown");
-
-    // The next one reads the token's balance, which is zero.
-    await refreshOnce(page, []);
-
-    expect(newTokenRow(page)).toContain("0.0000");
-});
-
-test("closed and opened again before any refresh has read its balance, the new token's line still reads quantity unknown", async () => {
-    const closed = await bootOnAddress();
-    holdNextRefresh(closed);
-    await addNewToken(closed);
-    cleanupPopup();
-
-    // The refresh this boot starts reads no token's balance: the boot's stub
-    // of refreshBalances() reads none.
-    const page = await bootPopup(undefined, { storage: closed.storage });
-    expect(page.visibleViews()).toEqual(["address"]);
-    const row = newTokenRow(page);
-    expect(row).toContain("quantity unknown");
-    expect(row).not.toContain("0.0000");
-
-    await refreshOnce(page, [MILLION]);
-
-    expect(newTokenRow(page)).toContain("1000000.0000");
-});
-
-test("a refresh that could not read the new token's balance leaves its line quantity unknown", async () => {
-    const page = await bootOnAddress();
-    const finish = holdNextRefresh(page);
-    await addNewToken(page);
-
-    await finish(null);
-
-    // Drawn again: the ETH balance it fetched is shown.
-    expect(page.node("address-balances").innerHTML).toContain("2.0000");
-    expect(newTokenRow(page)).toContain("quantity unknown");
-});
-
-test("AddressToken for the new token reads quantity unknown until the refresh returns, then the fetched balance", async () => {
-    const page = await bootOnAddress();
-    const finish = holdNextRefresh(page);
-    await addNewToken(page);
-
-    await openToken(page, NEW_TOKEN.toLowerCase());
-
-    expect(page.visibleViews()).toEqual(["address-token"]);
-    const before = page.node("address-token-balance").innerHTML;
-    expect(before).toContain("quantity unknown");
-    expect(before).not.toContain("0.0000");
-
-    await finish([MILLION]);
-
-    expect(page.node("address-token-balance").innerHTML).toContain(
-        "1000000.0000",
-    );
-});
-
-test("Send for the new token reads its balance as unknown before any refresh has read it, and Max says so", async () => {
-    const page = await bootOnAddress();
-    const finish = holdNextRefresh(page);
-    await addNewToken(page);
-    await openToken(page, NEW_TOKEN.toLowerCase());
-
-    await page.click("btn-address-token-send");
-
-    expect(page.visibleViews()).toEqual(["send"]);
-    expect(page.text("send-balance")).toBe("Current balance: unknown (NEW)");
-
-    await page.click("btn-send-max");
-
-    expect(page.text("flash-msg")).toBe("This token's balance is unknown.");
-    await finish([MILLION]);
-});
-
-test("a token added by contract address on SettingsAddToken reads quantity unknown until the refresh returns", async () => {
-    const page = await bootPopup(unversionedValidProfile());
-    expect(page.visibleViews()).toEqual(["main"]);
-    const finish = holdNextRefresh(page);
-
-    await page.click("btn-settings");
-    await addOnSettingsAddToken(page);
-    await page.click("btn-settings-addtoken-back");
-    await page.click("btn-settings-back");
-    expect(page.visibleViews()).toEqual(["main"]);
-    const onHome = newTokenRow(page, "wallet-list");
-    expect(onHome).toContain("quantity unknown");
-    expect(onHome).not.toContain("0.0000");
-
-    await openAddress(page);
-    const onAddress = newTokenRow(page);
-    expect(onAddress).toContain("quantity unknown");
-    expect(onAddress).not.toContain("0.0000");
-
-    await finish([MILLION]);
-
-    expect(newTokenRow(page)).toContain("1000000.0000");
-});
-
-test("a refresh that returns while AddressToken is up draws its balance again", async () => {
-    const page = await bootPopup(
-        unversionedValidProfile({
-            currentView: "address-token",
-            viewStack: ["main", "address"],
-            selectedWallet: 0,
-            selectedAddress: 0,
-            selectedToken: "ETH",
-        }),
-    );
-    expect(page.visibleViews()).toEqual(["address-token"]);
-    expect(page.node("address-token-balance").innerHTML).toContain("1.5000");
-
-    await refreshOnce(page, null);
-
-    expect(page.node("address-token-balance").innerHTML).toContain("2.0000");
-});
-
-test("a token removed before any refresh has read its balance leaves nothing stored, and adding it again tracks it once", async () => {
-    const page = await bootPopup(unversionedValidProfile());
-    const removeButton = firstRemoveButton(page);
-    const stored = () => page.storage.read("autistmask");
-
-    await page.click("btn-settings");
-    await addOnSettingsAddToken(page);
-    // Settings opened again from Home draws its list with the token in it.
-    await page.click("btn-settings-addtoken-back");
-    await page.click("btn-settings-back");
-    await page.click("btn-settings");
-    await removeButton.press();
-    await page.settle();
-
-    expect(stored().trackedTokens).toEqual([]);
-    // Nothing in the stored record names the token any more.
-    expect(JSON.stringify(stored()).toLowerCase()).not.toContain(
-        NEW_TOKEN.toLowerCase(),
-    );
-
-    await addOnSettingsAddToken(page);
-    // A second add of the same token is refused.
-    page.node("settings-addtoken-address").value = NEW_TOKEN;
-    await page.click("btn-settings-addtoken-manual");
-
-    const added = { address: NEW_TOKEN, symbol: "NEW", decimals: 18 };
-    expect(stored().trackedTokens).toEqual([
-        { ...added, name: "New Token", balanceNotFetched: true },
-    ]);
-
-    await refreshOnce(page, []);
-
-    expect(stored().trackedTokens).toEqual([{ ...added, name: "New Token" }]);
-});
-
-test("a refresh on another network leaves the new token reading quantity unknown on its own", async () => {
-    // Sepolia tracks a token at the same contract address, also just added.
-    const sepoliaToken = {
-        address: NEW_TOKEN,
-        symbol: "SEP",
-        name: "Sepolia Token",
-        decimals: 18,
-    };
-    const page = await bootOnAddress({
-        networkTrackedTokens: {
-            sepolia: [{ ...sepoliaToken, balanceNotFetched: true }],
-        },
-    });
-    const finishMainnet = holdNextRefresh(page);
-    await addNewToken(page);
-
-    await page.click("btn-settings");
-    await chooseNetwork(page, "sepolia");
-    // The refresh Add started returns after the switch and writes nothing.
-    await finishMainnet([MILLION]);
-    // Sepolia's refresh reads the balance of its own token.
-    await refreshOnce(page, []);
-
-    const stored = page.storage.read("autistmask");
-    expect(stored.trackedTokens).toEqual([sepoliaToken]);
-    expect(stored.networkTrackedTokens.mainnet[0].balanceNotFetched).toBe(true);
-
-    await chooseNetwork(page, "mainnet");
-    await page.click("btn-settings-back");
-
-    expect(page.visibleViews()).toEqual(["address"]);
-    expect(newTokenRow(page)).toContain("quantity unknown");
-
-    await refreshOnce(page, [MILLION]);
-
-    expect(newTokenRow(page)).toContain("1000000.0000");
-});
-
-test("a refresh keeps a token that another page added after this page loaded", async () => {
-    const page = await bootOnAddress();
-    const finish = holdNextRefresh(page);
-    await addNewToken(page);
-    const otherAdded = { ...OTHER_TOKEN, balanceNotFetched: true };
-    anotherPageTracks(page, [
-        { ...NEW_TRACKED, balanceNotFetched: true },
-        otherAdded,
-    ]);
-
-    await finish([MILLION]);
-
-    expect(page.storage.read("autistmask").trackedTokens).toEqual([
-        NEW_TRACKED,
-        otherAdded,
-    ]);
-    expect(newTokenRow(page)).toContain("1000000.0000");
-});
-
-test("a refresh does not bring back a token that another page removed after this page loaded", async () => {
-    const page = await bootOnAddress({ trackedTokens: [OTHER_TOKEN] });
-    const finish = holdNextRefresh(page);
-    await addNewToken(page);
-    anotherPageTracks(page, [{ ...NEW_TRACKED, balanceNotFetched: true }]);
-
-    await finish([MILLION]);
-
-    expect(page.storage.read("autistmask").trackedTokens).toEqual([
-        NEW_TRACKED,
-    ]);
-});

tests/addressKey.test.js

@@ -161,7 +161,7 @@ function click(element) {
 
 // show() starts the fee estimate without awaiting it; this lets it settle.
 async function settle() {
-    for (let i = 0; i < 10; i++) await jest.advanceTimersByTimeAsync(0);
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
 }
 
 // ------------------------------------------------------------ harness
@@ -188,11 +188,7 @@ let sent;
 // handler to the buttons it drew, as the browser's fresh list would have.
 let plusButton;
 
-// showFlash() starts a timer that clears the message one or two seconds later.
-// Each test here runs on fake timers and drops them in afterEach, so that timer
-// never outlives the test.
 beforeEach(() => {
-    jest.useFakeTimers();
     approvalDetails = null;
     sent = [];
     mockNode.broadcast = [];
@@ -243,7 +239,6 @@ beforeEach(() => {
 });
 
 afterEach(() => {
-    jest.useRealTimers();
     jest.restoreAllMocks();
 });
 

tests/addressValue.test.js

@@ -1,9 +1,9 @@
 // The USD total of an address that holds something this build cannot price
 // (issue #261).
 //
-// Only a token with a price feed has a price, so an address can hold real
-// assets with no price attached. Summing what is priced and printing the result
-// as the total says "$0.00" for an address holding nothing but unpriced tokens —
+// Prices exist for the top 25 tokens only, so an address can hold real assets
+// with no price attached. Summing what is priced and printing the result as
+// the total says "$0.00" for an address holding nothing but unpriced tokens —
 // worth-nothing and worth-an-unknown-amount collapsed into one number, in the
 // direction that matters. The two are separate facts here, the same way an
 // absent holders_count is not a count of zero.
@@ -63,7 +63,7 @@ const PARTLY_PRICED = {
 beforeEach(() => {
     clearPrices();
     prices.ETH = 2000;
-    prices[USDC] = 1;
+    prices.USDC = 1;
     state.wallets = [];
     state.trackedTokens = [];
     state.showZeroBalanceTokens = false;

tests/approvalAmount.test.js

@@ -90,11 +90,9 @@ beforeEach(() => {
 });
 
 describe("resolveTokenDecimals", () => {
-    // The bundled list is read only for a token on Ethereum Mainnet.
     test("prefers the bundled list", () => {
         state.trackedTokens = [{ address: USDC, symbol: "USDC", decimals: 2 }];
-        const sources = { chainId: "0x1", trackedTokens: state.trackedTokens };
-        expect(resolveTokenDecimals(USDC, sources)).toBe(6);
+        expect(resolveTokenDecimals(USDC, state)).toBe(6);
     });
 
     test("reads a token the user tracks", () => {
@@ -126,8 +124,7 @@ describe("resolveTokenDecimals", () => {
     // answers 0 is used rather than fallen past like the unusable entry above.
     test("uses a bundled scale of zero", () => {
         state.trackedTokens = [{ address: SLP, symbol: "SLP", decimals: 18 }];
-        const sources = { chainId: "0x1", trackedTokens: state.trackedTokens };
-        expect(resolveTokenDecimals(SLP, sources)).toBe(0);
+        expect(resolveTokenDecimals(SLP, state)).toBe(0);
     });
 
     test("uses a tracked scale of zero", () => {

tests/approvalBundledListSepolia.test.js

@@ -1,169 +0,0 @@
-// The approval screen for a site's Sepolia transfer of the contract at USDC's
-// mainnet address, while Sepolia is active.
-//
-// The bundled token list holds Ethereum Mainnet contracts. The contract at the
-// same address on Sepolia is another token, but the screen named it USDC and
-// scaled its amount at USDC's decimals
-// (https://git.eeqj.de/sneak/AutistMask/issues/632). The bundled list now names
-// a token only on Ethereum Mainnet. The same screen for a mainnet transfer of
-// USDC, while Sepolia is active, still names USDC.
-//
-// Driven through the real approval screen, against the minimal DOM stub
-// tests/approvalTokenNetwork.test.js uses.
-
-globalThis.chrome = {
-    storage: { local: { get: async () => ({}), set: async () => {} } },
-};
-
-const { Interface } = require("ethers");
-const { state } = require("../src/shared/state");
-const { NETWORKS } = require("../src/shared/networks");
-const approval = require("../src/popup/views/approval");
-
-const FROM = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
-const RECIPIENT = "0x711e691962E5c054b78071C789A0C8CE657377aD";
-// USDC's address on Ethereum Mainnet, where the bundled list names it.
-const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
-
-// FROM sends 1234500000 base units to RECIPIENT.
-const TRANSFER_DATA = new Interface([
-    "function transfer(address to, uint256 amount)",
-]).encodeFunctionData("transfer", [RECIPIENT, 1234500000n]);
-
-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);
-}
-
-// One line of the decoded details: its label and what is drawn under it.
-function decodedLine(label) {
-    return node("approve-tx-decoded-details")
-        .innerHTML.split('<div class="mb-2">')
-        .find((line) =>
-            line.startsWith(`<div class="text-muted">${label}</div>`),
-        );
-}
-
-// Open the approval screen, with Sepolia active, for the site's transaction
-// sending TRANSFER_DATA to the contract at USDC's address on the network with
-// chain id `chainId`.
-async function showTransfer(chainId) {
-    globalThis.document = makeDocument();
-    globalThis.window = { location: { search: "" }, close: () => {} };
-    globalThis.chrome.runtime = {
-        connect: () => ({ postMessage: () => {} }),
-        sendMessage: (msg, reply) => {
-            if (!reply) return;
-            reply({
-                type: "tx",
-                origin: "https://dapp.example",
-                isPhishingDomain: false,
-                approvedFrom: FROM,
-                approvedTx: {
-                    type: 2,
-                    from: FROM,
-                    chainId,
-                    nonce: "0x7",
-                    gasLimit: "0x30d40",
-                    maxPriorityFeePerGas: "0x3b9aca00",
-                    maxFeePerGas: "0x77359400",
-                    to: USDC,
-                    value: "0x0",
-                    data: TRANSFER_DATA,
-                    accessList: [],
-                },
-            });
-        },
-    };
-    state.networkId = "sepolia";
-    state.trackedTokens = [];
-    state.networkTrackedTokens = {};
-    state.activeAddress = FROM;
-    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: [] },
-            ],
-        },
-    ];
-    state.currentView = null;
-    approval.init({});
-    await approval.show(1);
-}
-
-test("names no token, and states the amount in base units", async () => {
-    await showTransfer(NETWORKS.sepolia.chainId);
-    expect(state.currentView).toBe("approve-tx");
-    expect(node("approve-tx-to").innerHTML).not.toContain("USDC");
-    expect(decodedLine("Token")).toContain(
-        '<div class="font-bold">Unknown token</div>',
-    );
-    expect(decodedLine("Amount")).toContain(
-        '<div class="font-bold">1234500000 base units (decimals unknown)</div>',
-    );
-});
-
-// A transaction is named for its own network, not the active one.
-test("a mainnet transfer of USDC is still named and scaled as USDC", async () => {
-    await showTransfer(NETWORKS.mainnet.chainId);
-    expect(state.currentView).toBe("approve-tx");
-    expect(decodedLine("Token")).toContain('<div class="font-bold">USDC</div>');
-    expect(decodedLine("Amount")).toContain(
-        '<div class="font-bold">1234.5000 USDC</div>',
-    );
-});

tests/approvalWindow.test.js

@@ -12,7 +12,6 @@ const {
     cleanupPopup,
     settle,
     unversionedValidProfile,
-    ADDRESS,
 } = require("./support/popupBoot");
 
 afterEach(cleanupPopup);
@@ -175,136 +174,3 @@ test("a connection prompt in the toolbar popup leaves the browser window alone",
     expect(windows.updates).toEqual([]);
     expect(env.pageErrors).toEqual([]);
 });
-
-// Each row holds a transaction or signature approval as the background
-// describes it, plus the element ids of the screen that shows it. `refusal` is
-// the message the background refuses a Reject with.
-const TX_AND_SIGN_APPROVALS = [
-    {
-        kind: "transaction",
-        view: "approve-tx",
-        reject: "btn-reject-tx",
-        error: "approve-tx-error",
-        type: "AUTISTMASK_TX_RESPONSE",
-        refusal: "This transaction is already being sent.",
-        approval: {
-            type: "tx",
-            approvedFrom: ADDRESS,
-            approvedTx: {
-                chainId: 1,
-                to: ADDRESS,
-                value: "0",
-                data: "0x",
-                gasLimit: "21000",
-                maxFeePerGas: "1000000000",
-                maxPriorityFeePerGas: "1000000000",
-                nonce: 0,
-            },
-        },
-    },
-    {
-        kind: "signature",
-        view: "approve-sign",
-        reject: "btn-reject-sign",
-        error: "approve-sign-error",
-        type: "AUTISTMASK_SIGN_RESPONSE",
-        refusal: "This request is already being signed.",
-        approval: {
-            type: "sign",
-            approvedFrom: ADDRESS,
-            signParams: {
-                method: "personal_sign",
-                message: "0x48656c6c6f",
-                from: ADDRESS,
-            },
-        },
-    },
-];
-
-// A closed transaction or signature window leaves its request pending
-// (https://git.eeqj.de/sneak/AutistMask/issues/673). So Reject closes the
-// window only once the background has the rejection. A message sent as the
-// window closes can be lost, and the request would stay pending although the
-// user rejected it.
-test.each(TX_AND_SIGN_APPROVALS)(
-    "Reject on a $kind approval closes the window only once the background has answered",
-    async ({ view, reject, type, approval }) => {
-        let describeApproval = null;
-        let answerReject = null;
-        const sent = [];
-        const env = await bootPopup(unversionedValidProfile(), {
-            search: "?approval=approval-1",
-            runtime: {
-                connect: () => ({ postMessage: () => {} }),
-                sendMessage: (msg, reply) => {
-                    if (msg.type === "AUTISTMASK_GET_APPROVAL") {
-                        describeApproval = reply;
-                    }
-                    if (msg.type === type) {
-                        sent.push(msg);
-                        answerReject = reply;
-                    }
-                },
-            },
-        });
-        describeApproval({
-            ...approval,
-            origin: "https://dapp.example",
-            isPhishingDomain: false,
-        });
-        await settle();
-        expect(env.visibleViews()).toEqual([view]);
-        const close = jest.fn();
-        globalThis.window.close = close;
-
-        const clicked = env.click(reject);
-        await settle();
-        expect(sent).toEqual([{ type, id: "approval-1", approved: false }]);
-        expect(close).not.toHaveBeenCalled();
-
-        answerReject(null);
-        await clicked;
-        expect(close).toHaveBeenCalledTimes(1);
-        expect(env.pageErrors).toEqual([]);
-    },
-);
-
-// After Confirm or Sign, the background refuses a Reject while the transaction
-// is being sent or the signature checked. The request is not rejected then, so
-// the window stays open and shows the background's message.
-test.each(TX_AND_SIGN_APPROVALS)(
-    "Reject on a $kind approval that the background refuses shows the background's message and keeps the window open",
-    async ({ view, reject, error, type, refusal, approval }) => {
-        let describeApproval = null;
-        let answerReject = null;
-        const env = await bootPopup(unversionedValidProfile(), {
-            search: "?approval=approval-1",
-            runtime: {
-                connect: () => ({ postMessage: () => {} }),
-                sendMessage: (msg, reply) => {
-                    if (msg.type === "AUTISTMASK_GET_APPROVAL") {
-                        describeApproval = reply;
-                    }
-                    if (msg.type === type) answerReject = reply;
-                },
-            },
-        });
-        describeApproval({
-            ...approval,
-            origin: "https://dapp.example",
-            isPhishingDomain: false,
-        });
-        await settle();
-        const close = jest.fn();
-        globalThis.window.close = close;
-
-        const clicked = env.click(reject);
-        await settle();
-        answerReject({ error: refusal, retryable: false });
-        await clicked;
-        expect(close).not.toHaveBeenCalled();
-        expect(env.visibleViews()).toEqual([view]);
-        expect(env.text(error)).toBe(refusal);
-        expect(env.pageErrors).toEqual([]);
-    },
-);

tests/backgroundApproval.test.js

@@ -241,11 +241,10 @@ function loadBackground(options) {
     let connectListener = null;
     const created = [];
     const removed = [];
-    // Every URL the background put on the browser action. When a test gives
-    // the URL the action holds before the worker starts, that URL comes
-    // first. A site approval raised through action.openPopup() opens no
-    // window at all, so this is the only place its id appears.
-    const actionPopups = opts.toolbarPopup ? [opts.toolbarPopup] : [];
+    // Every URL the background put on the browser action. A site approval
+    // raised through action.openPopup() opens no window at all, so this is
+    // the only place its id appears.
+    const actionPopups = [];
     const openPopup = jest.fn(() => Promise.resolve());
 
     global.chrome = {
@@ -537,18 +536,7 @@ async function settleIncludingRejections() {
     await new Promise((resolve) => setImmediate(resolve));
 }
 
-// While an approval is pending, the background starts a 20-second timer to
-// keep itself running. The timer is stubbed and never starts, so no test in
-// this file leaves it running.
-let keepRunningTimer;
-beforeEach(() => {
-    keepRunningTimer = jest
-        .spyOn(global, "setInterval")
-        .mockImplementation(() => 1);
-});
-
 afterEach(() => {
-    keepRunningTimer.mockRestore();
     delete global.chrome;
     jest.resetModules();
 });
@@ -786,9 +774,10 @@ describe("one transaction approval at a time", () => {
 
     // The user closes an approval window that looks hung while the attempt
     // behind it is still running, and that attempt then fails in a way that
-    // leaves the approval standing for a retry. The toolbar popup opens it, so
-    // the user can still retry it, and answering it frees the slot.
-    test("an approval whose window closed under a failed attempt is retried from the toolbar popup, and frees the next request", async () => {
+    // would normally leave the approval standing for a retry. There is no
+    // window left to retry in, so leaving it standing answers the requesting
+    // page never — and holds the slot for the life of the worker with it.
+    test("an approval whose window closed under a failed attempt is answered, and frees the next request", async () => {
         const stalled = deferred();
         const bg = loadBackground();
 
@@ -819,28 +808,11 @@ describe("one transaction approval at a time", () => {
 
         stalled.resolve();
         await settle();
-        expect(first.result()).toBeNull();
-        expect(bg.actionPopups[bg.actionPopups.length - 1]).toBe(
-            "src/popup/index.html?approval=" + first.id(),
-        );
+        expect(first.result()).toEqual({
+            error: { code: 4001, message: "User rejected the request." },
+        });
 
         bg.setStateReadHook(null);
-        bg.broadcastTransaction.mockResolvedValue({ hash: "0xfeed" });
-        bg.send(
-            {
-                type: "AUTISTMASK_TX_RESPONSE",
-                id: first.id(),
-                approved: true,
-                rawSignedTx: await signedAtNonce(NONCE),
-            },
-            { url: bg.fromPopup.url },
-        );
-        await settle();
-        expect(first.result()).toEqual({ result: "0xfeed" });
-        expect(bg.actionPopups[bg.actionPopups.length - 1]).toBe(
-            "src/popup/index.html",
-        );
-
         const second = bg.requestTx();
         await settle();
         expect(second.result()).toBeNull();
@@ -881,10 +853,8 @@ describe("one transaction approval at a time", () => {
         const first = bg.requestTx();
         await settle();
 
-        bg.send(
-            { type: "AUTISTMASK_TX_RESPONSE", id: first.id(), approved: false },
-            { url: bg.fromPopup.url },
-        );
+        // The user closes the approval window, which rejects it.
+        bg.closeWindow(1);
         await settle();
         expect(first.result()).toEqual({
             error: { code: 4001, message: "User rejected the request." },
@@ -927,7 +897,7 @@ describe("the worker keeps running while an approval is pending", () => {
         try {
             const bg = loadBackground();
             const calls = global.chrome.runtime.getPlatformInfo;
-            const pending = bg.requestTx();
+            bg.requestTx();
             await settle();
             expect(startTimer).toHaveBeenCalledTimes(1);
             expect(startTimer.mock.calls[0][1]).toBe(20000);
@@ -936,23 +906,11 @@ describe("the worker keeps running while an approval is pending", () => {
             tick();
             expect(calls).toHaveBeenCalledTimes(1);
 
-            // A closed window leaves the approval pending, so the calls go on.
+            // The user closes the approval window, which rejects it.
             bg.closeWindow(1);
             await settle();
             tick();
-            expect(calls).toHaveBeenCalledTimes(2);
-
-            bg.send(
-                {
-                    type: "AUTISTMASK_TX_RESPONSE",
-                    id: pending.id(),
-                    approved: false,
-                },
-                { url: bg.fromPopup.url },
-            );
-            await settle();
-            tick();
-            expect(calls).toHaveBeenCalledTimes(2);
+            expect(calls).toHaveBeenCalledTimes(1);
             expect(stopTimer).toHaveBeenCalledWith(1);
         } finally {
             startTimer.mockRestore();
@@ -1883,225 +1841,6 @@ describe("the interlock releases a failed attempt", () => {
     });
 });
 
-// A transaction or signature approval stays pending when its window closes.
-// The browser can close that window when the user clicks away from it, for
-// example to copy the password from a password manager. The toolbar popup then
-// opens the approval, and the user answers it there
-// (https://git.eeqj.de/sneak/AutistMask/issues/673).
-describe("a closed approval window leaves the request pending", () => {
-    // The URL the toolbar popup opens now.
-    function toolbarPopup(bg) {
-        return bg.actionPopups[bg.actionPopups.length - 1];
-    }
-
-    test("the toolbar popup opens a closed transaction approval, and approving it there sends", async () => {
-        const bg = loadBackground();
-        const pending = bg.requestTx();
-        await settle();
-
-        bg.closeWindow(1);
-        await settle();
-        expect(pending.result()).toBeNull();
-        expect(toolbarPopup(bg)).toBe(
-            "src/popup/index.html?approval=" + pending.id(),
-        );
-
-        bg.broadcastTransaction.mockResolvedValue({ hash: "0xfeed" });
-        bg.send(
-            {
-                type: "AUTISTMASK_TX_RESPONSE",
-                id: pending.id(),
-                approved: true,
-                rawSignedTx: await signedAtNonce(NONCE),
-            },
-            { url: bg.fromPopup.url },
-        );
-        await settle();
-        expect(pending.result()).toEqual({ result: "0xfeed" });
-        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
-    });
-
-    test("Reject in the toolbar popup answers 4001, and the toolbar popup opens the wallet again", async () => {
-        const bg = loadBackground();
-        const pending = bg.requestSign();
-        await settle();
-
-        bg.closeWindow(1);
-        await settle();
-        expect(pending.result()).toBeNull();
-        expect(toolbarPopup(bg)).toBe(
-            "src/popup/index.html?approval=" + pending.id(),
-        );
-
-        const reject = bg.send(
-            {
-                type: "AUTISTMASK_SIGN_RESPONSE",
-                id: pending.id(),
-                approved: false,
-            },
-            { url: bg.fromPopup.url },
-        );
-        await settle();
-        expect(pending.result()).toEqual({
-            error: { code: 4001, message: "User rejected the request." },
-        });
-        // The popup closes its window only once this answer arrives.
-        expect(reject.sendResponse).toHaveBeenCalledWith(null);
-        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
-    });
-
-    test("with two closed, the toolbar popup opens the older one first, then the other", async () => {
-        const bg = loadBackground();
-        const sign = bg.requestSign();
-        await settle();
-        const signId = sign.id();
-        const tx = bg.requestTx();
-        await settle();
-
-        // The signature request is in window 1 and the transaction in window
-        // 2. The newer window is closed first.
-        bg.closeWindow(2);
-        bg.closeWindow(1);
-        await settle();
-        expect(toolbarPopup(bg)).toBe(
-            "src/popup/index.html?approval=" + signId,
-        );
-
-        bg.send(
-            { type: "AUTISTMASK_SIGN_RESPONSE", id: signId, approved: false },
-            { url: bg.fromPopup.url },
-        );
-        await settle();
-        expect(toolbarPopup(bg)).toBe(
-            "src/popup/index.html?approval=" + tx.id(),
-        );
-
-        const reject = bg.send(
-            { type: "AUTISTMASK_TX_RESPONSE", id: tx.id(), approved: false },
-            { url: bg.fromPopup.url },
-        );
-        await settle();
-        expect(tx.result()).toEqual({
-            error: { code: 4001, message: "User rejected the request." },
-        });
-        expect(reject.sendResponse).toHaveBeenCalledWith(null);
-        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
-    });
-
-    // The user can close the window while the attempt after Confirm runs. That
-    // attempt answers the request, so meanwhile the toolbar popup opens the
-    // wallet. Opened from the toolbar, the approval would look unanswered.
-    test("when the window closes during an attempt that sends, the toolbar popup keeps opening the wallet", async () => {
-        const bg = loadBackground();
-        const pending = bg.requestTx();
-        await settle();
-
-        const inFlight = deferred();
-        bg.broadcastTransaction.mockReturnValue(inFlight.promise);
-        bg.send(
-            {
-                type: "AUTISTMASK_TX_RESPONSE",
-                id: pending.id(),
-                approved: true,
-                rawSignedTx: await signedAtNonce(NONCE),
-            },
-            { url: bg.fromPopup.url },
-        );
-        await settle();
-        bg.closeWindow(1);
-        await settle();
-        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
-
-        inFlight.resolve({ hash: "0xfeed" });
-        await settle();
-        expect(pending.result()).toEqual({ result: "0xfeed" });
-        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
-    });
-
-    test("when the window closes during an attempt that fails retryably, the toolbar popup opens the wallet until the attempt ends, then the approval", async () => {
-        const stalled = deferred();
-        const bg = loadBackground();
-        const pending = bg.requestTx();
-        await settle();
-
-        bg.setStateReadHook(async () => {
-            await stalled.promise;
-            throw new Error("The wallet data could not be read.");
-        });
-        bg.send(
-            {
-                type: "AUTISTMASK_TX_RESPONSE",
-                id: pending.id(),
-                approved: true,
-                rawSignedTx: await signedAtNonce(NONCE),
-            },
-            { url: bg.fromPopup.url },
-        );
-        await settle();
-        bg.closeWindow(1);
-        await settle();
-        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
-
-        stalled.resolve();
-        await settle();
-        expect(pending.result()).toBeNull();
-        expect(toolbarPopup(bg)).toBe(
-            "src/popup/index.html?approval=" + pending.id(),
-        );
-
-        // A retry from the toolbar popup holds the approval again, so the
-        // toolbar popup opens the wallet while that retry runs.
-        bg.setStateReadHook(null);
-        const inFlight = deferred();
-        bg.broadcastTransaction.mockReturnValue(inFlight.promise);
-        bg.send(
-            {
-                type: "AUTISTMASK_TX_RESPONSE",
-                id: pending.id(),
-                approved: true,
-                rawSignedTx: await signedAtNonce(NONCE),
-            },
-            { url: bg.fromPopup.url },
-        );
-        await settle();
-        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
-
-        inFlight.resolve({ hash: "0xfeed" });
-        await settle();
-        expect(pending.result()).toEqual({ result: "0xfeed" });
-        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
-    });
-
-    test("an address switch still rejects a closed approval", async () => {
-        const bg = loadBackground();
-        const pending = bg.requestTx();
-        await settle();
-        bg.closeWindow(1);
-        await settle();
-        expect(pending.result()).toBeNull();
-
-        bg.send(
-            { type: "AUTISTMASK_ACTIVE_CHANGED" },
-            { url: bg.fromPopup.url },
-        );
-        await settle();
-        expect(pending.result()).toEqual({
-            error: { code: 4001, message: "User rejected the request." },
-        });
-        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
-    });
-
-    // The worker can stop while an approval waits with its window closed. The
-    // approval is lost with the worker, but the toolbar popup keeps its URL.
-    // The next worker points the toolbar popup back at the wallet.
-    test("a worker that starts points the toolbar popup back at the wallet", () => {
-        const bg = loadBackground({
-            toolbarPopup: "src/popup/index.html?approval=lost-approval",
-        });
-        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
-    });
-});
-
 // The claim is what makes one approval one broadcast, so it has to hold
 // against everything else that retires an approval, not just against a second
 // AUTISTMASK_TX_RESPONSE. Each of these paths used to resolve the waiting
@@ -2222,6 +1961,20 @@ describe("a claimed approval outlives every other retirement path", () => {
     });
 
     // The refusals above must not cost the rejection its ordinary meaning.
+    test("with no attempt running, closing the window still rejects", async () => {
+        const bg = loadBackground();
+        const pending = bg.requestTx();
+        await settle();
+
+        bg.closeWindow(1);
+        await settle();
+
+        expect(pending.result()).toEqual({
+            error: { code: 4001, message: "User rejected the request." },
+        });
+        expect(bg.broadcastTransaction).not.toHaveBeenCalled();
+    });
+
     test("with no attempt running, an active-address switch still rejects and closes", async () => {
         const bg = loadBackground();
         const pending = bg.requestTx();
@@ -2831,12 +2584,15 @@ describe("a site connection decided as the popup closes", () => {
         });
     });
 
-    // That skip must not reach a tx or sign approval. The popup connects its
-    // port in show() before it knows the approval's type, and the background
-    // sets portConnected without looking at the type either, so a tx approval
-    // carries the flag too. If the window event skipped it, windowClosed would
-    // never be set, and the toolbar popup would never open the approval.
-    test("a tx window closed with the port connected is still opened by the toolbar popup", async () => {
+    // The `isSite &&` half of that skip, which is what keeps it from reaching
+    // a tx or sign approval. The popup connects its port in show() before it
+    // knows the approval's type, and the background sets portConnected without
+    // looking at the type either, so a tx approval in the fallback window
+    // carries the flag too. Without the conjunct the window event would skip
+    // it, windowClosed would never be set, releaseApproval() would never settle
+    // it, and the page would hang — the #271 regression this guard is written
+    // around.
+    test("a tx window closed with the port connected still rejects", async () => {
         const bg = loadBackground();
         const pending = bg.requestTx();
         await settle();
@@ -2844,10 +2600,9 @@ describe("a site connection decided as the popup closes", () => {
         await settle();
         bg.closeWindow(1);
         await settle();
-        expect(pending.result()).toBeNull();
-        expect(bg.actionPopups[bg.actionPopups.length - 1]).toBe(
-            "src/popup/index.html?approval=" + pending.id(),
-        );
+        expect(pending.result()).toEqual({
+            error: { code: 4001, message: "User rejected the request." },
+        });
     });
 });
 
@@ -3239,14 +2994,13 @@ describe("where an approval window opens", () => {
         expect(bg.created[1].left).toBeUndefined();
         expect(bg.created[1].top).toBeUndefined();
 
-        // The request waits on the second window rather than failing. Once
-        // that window closes, the toolbar popup opens the request.
+        // The request waits on the second window rather than failing:
+        // closing that window is refusing the prompt.
         expect(sign.result()).toBeNull();
         bg.closeWindow(2);
         await settle();
-        expect(sign.result()).toBeNull();
-        expect(bg.actionPopups[bg.actionPopups.length - 1]).toBe(
-            "src/popup/index.html?approval=" + sign.id(),
-        );
+        expect(sign.result()).toEqual({
+            error: { code: 4001, message: "User rejected the request." },
+        });
     });
 });

tests/backgroundStateIsolation.test.js

@@ -103,18 +103,7 @@ function deferred() {
     return { promise, resolve };
 }
 
-// While an approval is pending, the background starts a 20-second timer to
-// keep itself running. The timer is stubbed and never starts, so no test in
-// this file leaves it running.
-let keepRunningTimer;
-beforeEach(() => {
-    keepRunningTimer = jest
-        .spyOn(global, "setInterval")
-        .mockImplementation(() => 1);
-});
-
 afterEach(() => {
-    keepRunningTimer.mockRestore();
     delete global.chrome;
 });
 

tests/balanceRefreshNetworkSwitch.test.js

@@ -6,10 +6,6 @@
 // approved a site's request, which changes only the stored record. Driven
 // through the real popup over a stored profile on Ethereum Mainnet. The same
 // refresh in the background is in tests/backgroundStateIsolation.test.js.
-//
-// The last test covers a balance refresh by the background that is saved while
-// a switch in Settings waits for the lock
-// (https://git.eeqj.de/sneak/AutistMask/issues/653).
 
 const {
     bootPopup,
@@ -45,7 +41,6 @@ async function holdRefresh(page) {
                 holders: null,
             },
         ];
-        return [];
     });
     const ticking = page.tick();
     await page.settle();
@@ -164,50 +159,3 @@ test("a refresh that returns after the background switched the network writes no
 
     expectNothingStored(page);
 });
-
-// The background's refresh saves Ethereum Mainnet's balances while the switch
-// in Settings waits for the lock. This page last saved a balance of "0" and no
-// token balances, the values that the switch sets.
-test("a background refresh saved while a switch in Settings waits for the lock leaves none of its balances stored", async () => {
-    const profile = unversionedValidProfile();
-    profile.wallets[0].addresses[0].balance = "0";
-    const page = await bootPopup(profile);
-    expect(page.pageErrors).toEqual([]);
-    const background = require("../src/background/state");
-    await page.click("btn-settings");
-
-    // The background takes the lock first and holds it until the test calls
-    // `letGo()`. It then saves balances as backgroundRefresh() in
-    // src/background/index.js does.
-    let letGo;
-    const refreshSave = background.updateState(async (fresh) => {
-        await new Promise((resolve) => {
-            letGo = resolve;
-        });
-        fresh.wallets[0].addresses[0].balance = "7.0";
-        fresh.wallets[0].addresses[0].tokenBalances = [
-            {
-                address: TOKEN_ADDRESS,
-                name: "Test Token",
-                symbol: "TST",
-                decimals: 18,
-                balance: "5.0",
-                holders: null,
-            },
-        ];
-        fresh.lastBalanceRefresh = Date.now();
-    });
-    await page.settle();
-
-    const select = page.node("settings-network");
-    select.value = "sepolia";
-    const switching = Promise.all(select.listeners.change.map((fn) => fn()));
-    await page.settle();
-
-    letGo();
-    await refreshSave;
-    await switching;
-    await page.settle();
-
-    expectNothingStored(page);
-});

tests/blockscoutEtherscanSettings.test.js

@@ -720,7 +720,6 @@ describe("the popup", () => {
                 tokenRow(TRACKED, "TRK"),
                 tokenRow(UNTRACKED, "TST"),
             ];
-            return [];
         });
         const ticking = page.tick();
         await page.settle();
@@ -765,7 +764,6 @@ describe("the popup", () => {
                 addr.tokenBalances = after
                     ? [tokenRow(TRACKED, "TRK"), tokenRow(UNTRACKED, "TST")]
                     : [tokenRow(TRACKED, "TRK")];
-                return [];
             });
 
             anotherPageSaves(page, { useBlockscout: after });

tests/bundledListScreens.test.js

@@ -1,81 +0,0 @@
-// The token screen, the Send screen and the confirmation screen for the
-// contract at USDC's mainnet address. No address holds it and the user does
-// not track it, so only the bundled token list can name it.
-//
-// The bundled token list holds Ethereum Mainnet contracts, so these screens
-// name the token from it on Ethereum Mainnet only
-// (https://git.eeqj.de/sneak/AutistMask/issues/632). Driven through the real
-// popup over a stored profile.
-
-const {
-    bootPopup,
-    cleanupPopup,
-    unversionedValidProfile,
-} = require("./support/popupBoot");
-
-const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
-const RECIPIENT = "0x711e691962E5c054b78071C789A0C8CE657377aD";
-
-afterEach(() => {
-    cleanupPopup();
-});
-
-// The popup reopened onto AddressToken for USDC's address, on `networkId`.
-function bootOnToken(networkId) {
-    return bootPopup(
-        unversionedValidProfile({
-            networkId,
-            currentView: "address-token",
-            viewStack: ["main", "address"],
-            selectedWallet: 0,
-            selectedAddress: 0,
-            selectedToken: USDC,
-        }),
-    );
-}
-
-// AddressToken's Send, then Review for 1 token to RECIPIENT.
-async function reviewSend(boot) {
-    await boot.click("btn-address-token-send");
-    expect(boot.visibleViews()).toEqual(["send"]);
-    boot.node("send-to").value = RECIPIENT;
-    boot.node("send-amount").value = "1";
-    await boot.click("btn-send-review");
-    expect(boot.visibleViews()).toEqual(["confirm-tx"]);
-}
-
-describe("on Ethereum Mainnet, the bundled list names the token", () => {
-    test("on the token screen", async () => {
-        const boot = await bootOnToken("mainnet");
-        expect(boot.visibleViews()).toEqual(["address-token"]);
-        expect(boot.text("address-token-title")).toContain("USDC");
-        const info = boot.node("address-token-contract-info").innerHTML;
-        expect(info).toContain(
-            '<span class="text-muted">Decimals:</span> 6</div>',
-        );
-    });
-
-    test("on the Send screen and the confirmation screen", async () => {
-        const boot = await bootOnToken("mainnet");
-        await reviewSend(boot);
-        expect(boot.text("send-balance")).toContain("USDC");
-        expect(boot.text("confirm-amount")).toContain("USDC");
-    });
-});
-
-describe("with Sepolia active, the bundled list does not name the token", () => {
-    test("on the token screen", async () => {
-        const boot = await bootOnToken("sepolia");
-        expect(boot.visibleViews()).toEqual(["address-token"]);
-        expect(boot.text("address-token-title")).not.toContain("USDC");
-        const info = boot.node("address-token-contract-info").innerHTML;
-        expect(info).not.toContain("Decimals:");
-    });
-
-    test("on the Send screen and the confirmation screen", async () => {
-        const boot = await bootOnToken("sepolia");
-        await reviewSend(boot);
-        expect(boot.text("send-balance")).not.toContain("USDC");
-        expect(boot.text("confirm-amount")).not.toContain("USDC");
-    });
-});

tests/chainSwitchGate.test.js

@@ -56,18 +56,7 @@ async function settle() {
     for (let i = 0; i < 50; i++) await Promise.resolve();
 }
 
-// While an approval is pending, the background starts a 20-second timer to
-// keep itself running. The timer is stubbed and never starts, so no test in
-// this file leaves it running.
-let keepRunningTimer;
-beforeEach(() => {
-    keepRunningTimer = jest
-        .spyOn(global, "setInterval")
-        .mockImplementation(() => 1);
-});
-
 afterEach(() => {
-    keepRunningTimer.mockRestore();
     delete global.chrome;
 });
 

tests/coldWorkerChainSwitch.test.js

@@ -64,18 +64,7 @@ async function settle() {
     for (let i = 0; i < 50; i++) await Promise.resolve();
 }
 
-// While an approval is pending, the background starts a 20-second timer to
-// keep itself running. The timer is stubbed and never starts, so no test in
-// this file leaves it running.
-let keepRunningTimer;
-beforeEach(() => {
-    keepRunningTimer = jest
-        .spyOn(global, "setInterval")
-        .mockImplementation(() => 1);
-});
-
 afterEach(() => {
-    keepRunningTimer.mockRestore();
     delete global.chrome;
 });
 

tests/coldWorkerSendTransaction.test.js

@@ -76,18 +76,7 @@ async function settle() {
     for (let i = 0; i < 60; i++) await Promise.resolve();
 }
 
-// While an approval is pending, the background starts a 20-second timer to
-// keep itself running. The timer is stubbed and never starts, so no test in
-// this file leaves it running.
-let keepRunningTimer;
-beforeEach(() => {
-    keepRunningTimer = jest
-        .spyOn(global, "setInterval")
-        .mockImplementation(() => 1);
-});
-
 afterEach(() => {
-    keepRunningTimer.mockRestore();
     delete global.chrome;
 });
 

tests/confirmTxNetworkSwitch.test.js

@@ -226,7 +226,6 @@ const PRIVATE_KEY = "0x" + "11".repeat(32);
 const HOLDER = new Wallet(PRIVATE_KEY).address;
 const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
 const TOKEN = "0x7070707070707070707070707070707070707070";
-const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
 const PASSWORD = "correct horse battery staple";
 
 function el(id) {
@@ -319,7 +318,7 @@ async function switchReopenAndGoBack(reviewedOn, switchedTo) {
     setBackRenderer(makeBackRenderer(state, { confirmTx }));
     confirmTx.init({});
     prices.ETH = 2000;
-    prices[USDC] = 1;
+    prices.USDC = 1;
     mockNode.asked = [];
     global.fetch.mockClear();
     goBack();
@@ -642,7 +641,7 @@ describe.each([
         test("of an ERC-20 token, links the token contract to that network's explorer and prices the token by that network", async () => {
             mockNode.tokenUnits[reviewedOn] = 50000000n;
             await review(reviewedOn, {
-                token: USDC,
+                token: TOKEN,
                 tokenSymbol: "USDC",
                 tokenDecimals: 6,
                 amount: "10",
@@ -653,7 +652,7 @@ describe.each([
                 "ERC-20 token transfer (USDC)",
             );
             expect(el("confirm-token-contract").innerHTML).toContain(
-                `href="${explorerUrl}/address/${USDC}"`,
+                `href="${explorerUrl}/address/${TOKEN}"`,
             );
             expect(el("confirm-amount").textContent).toBe(
                 "10.0000 USDC" + usdOn(reviewedOn, "$10.00"),

tests/connectedSitesWorkerRestart.test.js

@@ -57,18 +57,7 @@ async function settle() {
     for (let i = 0; i < 50; i++) await Promise.resolve();
 }
 
-// While an approval is pending, the background starts a 20-second timer to
-// keep itself running. The timer is stubbed and never starts, so no test in
-// this file leaves it running.
-let keepRunningTimer;
-beforeEach(() => {
-    keepRunningTimer = jest
-        .spyOn(global, "setInterval")
-        .mockImplementation(() => 1);
-});
-
 afterEach(() => {
-    keepRunningTimer.mockRestore();
     delete global.chrome;
     jest.resetModules();
 });

tests/deleteAddress.test.js

@@ -153,7 +153,7 @@ describe("the balance warning on the removal confirmation", () => {
 
     test("the USD total is shown when prices are known", () => {
         prices.ETH = 2000;
-        prices[USDC] = 1;
+        prices.USDC = 1;
         expect(balanceWarningHtml(TOKEN_ONLY)).toContain("Total: $2,500.00");
         expect(balanceWarningHtml(ETH_ONLY)).toContain("Total: $3,000.00");
     });

tests/deleteWalletLostPassword.test.js

@@ -102,17 +102,6 @@ function makeDocument() {
 
 // ------------------------------------------------------------ harness
 
-// showFlash() starts a timer that clears the message two seconds later. Each
-// test here runs on fake timers and drops them in afterEach, so that timer
-// never outlives the test.
-beforeEach(() => {
-    jest.useFakeTimers();
-});
-
-afterEach(() => {
-    jest.useRealTimers();
-});
-
 function wallet(name, secret, addresses) {
     return {
         type: "hd",

tests/e2e/dapp.js

@@ -43,15 +43,12 @@ const GAS_PRICE_WEI = BASE_FEE_WEI + PRIORITY_FEE_WEI;
 
 const STUB_BLOCK_NUMBER = 21000000;
 
-// A 32-byte zero word, returned for every eth_call but a price feed's
-// latestRoundData() (see rpcResult() below). It is what makes ethers'
+// A 32-byte zero word, returned for every eth_call. It is what makes ethers'
 // ENS reverse lookup resolve to "no resolver set" instead of throwing, and a
 // throw there reaches the console through src/shared/log.js, which fails the
 // run on its own.
 const ZERO_WORD = "0x" + "0".repeat(64);
 
-const SELECTOR_LATEST_ROUND_DATA = "0xfeaf968c";
-
 // One ETH, so the popup's balance lines render something and the wallet does
 // not look empty on the approval screen.
 const STUB_BALANCE_WEI = 10n ** 18n;
@@ -114,15 +111,6 @@ function rpcResult(req, state) {
         return latestBlock();
     }
 
-    // A price feed's latestRoundData() gets five zero words, as in network.js:
-    // a price of zero, which the wallet counts as no price.
-    const data = String(
-        (req.params && req.params[0] && req.params[0].data) || "",
-    );
-    if (method === "eth_call" && data.startsWith(SELECTOR_LATEST_ROUND_DATA)) {
-        return "0x" + "0".repeat(64 * 5);
-    }
-
     if (Object.prototype.hasOwnProperty.call(RPC_RESULTS, method)) {
         return RPC_RESULTS[method];
     }

tests/e2e/firefox/run.js

@@ -1035,14 +1035,11 @@ step(
     },
 );
 
-// A closed approval window leaves its request pending, and the toolbar button
-// opens it (https://git.eeqj.de/sneak/AutistMask/issues/673). WebDriver cannot
-// see the toolbar popup, so its page is opened in a tab, at the URL the
-// extension put on the button.
 step(
-    "a closed approval window leaves the request pending until it is rejected",
+    "closing an approval window rejects the request with 4001",
     async (env) => {
         const d = env.driver;
+        const before = env.server.broadcast.length;
 
         await d.switchToWindow(env.dappWindow);
         await startRequest(d, "sign-closed", "personal_sign", [
@@ -1056,45 +1053,15 @@ step(
 
         // Closed, not rejected: this is the windows.onRemoved path, which can
         // only fire if windows.create() handed back a window id for the
-        // approval to be matched against. Without that id the toolbar button
-        // never opens the approval, and this step fails.
+        // approval to be matched against — call site 4 in the issue, and the
+        // reason suppressing that write-back turns this step red.
         await d.closeWindow(env.dappWindow);
-        const outcome = await settleRequest(d, "sign-closed", 2000);
+
+        await assertUserRejection(d, "sign-closed", "a closed approval window");
         assert(
-            outcome.settled === "pending",
-            "closing the approval window answered the page: " +
-                JSON.stringify(outcome),
+            env.server.broadcast.length === before,
+            "a closed approval window still put a transaction on the node",
         );
-
-        await d.switchToWindow(env.popupWindow);
-        const url = await d.executeAsync(
-            `const done = arguments[arguments.length - 1];
-             browser.browserAction.getPopup({}).then(done, (e) => done(String(e)));`,
-        );
-        assert(
-            url.includes("?approval="),
-            "the toolbar button does not open the pending approval: " + url,
-        );
-        const reopened = await d.newWindow("tab");
-        await d.switchToWindow(reopened);
-        await d.navigate(url);
-        await d.waitVisible("#view-approve-sign");
-        await d.click("#btn-reject-sign");
-
-        await d.switchToWindow(env.dappWindow);
-        await assertUserRejection(
-            d,
-            "sign-closed",
-            "the signature request rejected from the toolbar button",
-        );
-
-        // A page may close only a window a script opened, so the tab can
-        // still be open.
-        const left = await d.findWindow((u) => u.includes("?approval="));
-        if (left) {
-            await d.switchToWindow(left);
-            await d.closeWindow(env.dappWindow);
-        }
     },
 );
 

tests/e2e/network.js

@@ -251,13 +251,8 @@ const SELECTOR_DECIMALS = "0x313ce567";
 const SELECTOR_SYMBOL = "0x95d89b41";
 const SELECTOR_NAME = "0x06fdde03";
 const SELECTOR_BALANCE_OF = "0x70a08231";
-const SELECTOR_LATEST_ROUND_DATA = "0xfeaf968c";
 
-// On any contract, a latestRoundData() call is answered with five zero words.
-// That is a round with a price of zero, which the wallet counts as no
-// price. So no screen shows a USD value beside the amounts the tests compare.
-//
-// Every other eth_call answers with a zero word except decimals(), symbol(),
+// Every eth_call still answers with a zero word except decimals(), symbol(),
 // name() and balanceOf() on the stub token. The wallet reads decimals() back
 // at signing time to compare with the scale the confirmation screen rendered
 // (issue #305). Adding the token by its contract address reads the first three
@@ -278,9 +273,6 @@ function ethCallResult(req, opts) {
     if (!call || typeof call !== "object") return ZERO_WORD;
     const data = String(call.data || call.input || "").toLowerCase();
     const to = String(call.to || "").toLowerCase();
-    if (data.startsWith(SELECTOR_LATEST_ROUND_DATA)) {
-        return "0x" + "0".repeat(64 * 5);
-    }
     if (to !== STUB_TOKEN.address) return ZERO_WORD;
     if (data.startsWith(SELECTOR_DECIMALS)) {
         return word(opts.tokenDecimalsOverride ?? STUB_TOKEN.decimals);
@@ -772,6 +764,11 @@ async function installNetworkStubs(ctx, opts) {
             }
         }
 
+        // CoinDesk price tick
+        if (url.hostname.endsWith("coindesk.com")) {
+            return jsonResponse(route, { Data: {} });
+        }
+
         // The interception canary's own request. Answered with nothing: what
         // is being observed is that it arrived here at all.
         if (url.href === WORKER_PROBE_URL) {

tests/e2e/run.js

@@ -969,8 +969,7 @@ test("a token added by its contract address is listed on the address screen (#15
     await visible(env.page, "#view-address");
 
     // No wait: the confirm renders the balance list before it shows the
-    // screen. The refresh it starts draws the list again, with the row still
-    // in it.
+    // screen, and nothing renders the list again while the screen is up.
     const row = env.page.locator(
         '#address-balances [data-token="' + STUB_TOKEN.address + '"]',
         { hasText: STUB_TOKEN.symbol },
@@ -4111,12 +4110,11 @@ async function waitForApprovalWindow(ctx, timeout = 30000) {
 // reservation exists.
 // How long the tab creation above is given to take effect before the request
 // that raises the next prompt is issued. Dismissing a browser-action popup
-// disconnects its port, and src/background/index.js calls
-// updateToolbarPopup() on that disconnect; issued too early, the next
-// request's setPopup() is undone by the previous popup's teardown,
-// chrome.action.openPopup() then rejects, and the fallback window it opens
-// dismisses the popup that was just raised — which settles the fresh approval
-// as a rejection before it can be seen.
+// disconnects its port, and src/background/index.js calls resetPopupUrl() on
+// that disconnect; issued too early, the next request's setPopup() is undone
+// by the previous popup's teardown, chrome.action.openPopup() then rejects,
+// and the fallback window it opens dismisses the popup that was just raised —
+// which settles the fresh approval as a rejection before it can be seen.
 // Every one of those steps was observed. 1.5s is comfortably past it.
 const APPROVAL_TAB_SETTLE_MS = 1500;
 
@@ -4142,17 +4140,6 @@ async function reserveApprovalTab(env) {
     return env.approvalTab;
 }
 
-// The URL the extension has put on the action: the page the toolbar button
-// opens.
-function toolbarPopupUrl(env) {
-    return env.page.evaluate(
-        () =>
-            new Promise((resolve) => {
-                chrome.action.getPopup({}, (u) => resolve(String(u)));
-            }),
-    );
-}
-
 // The site-connection prompt: the window the extension opened if it managed
 // to open one, and the reserved tab at the action's approval URL otherwise.
 async function openSiteApprovalPopup(env, timeout = 30000) {
@@ -4163,7 +4150,12 @@ async function openSiteApprovalPopup(env, timeout = 30000) {
             .find((p) => !p.isClosed() && p.url().includes("?approval="));
         if (existing) return existing;
 
-        const url = await toolbarPopupUrl(env);
+        const url = await env.page.evaluate(
+            () =>
+                new Promise((resolve) => {
+                    chrome.action.getPopup({}, (u) => resolve(String(u)));
+                }),
+        );
         if (url.includes("?approval=")) {
             await env.approvalTab.goto(url);
             return env.approvalTab;
@@ -5035,116 +5027,6 @@ test("eth_sendTransaction rejected broadcasts nothing (#183)", async (env) => {
     );
 });
 
-// A transaction or signature approval stays pending when its window closes.
-// The browser can close that window when the user clicks away from it, for
-// example to copy the password from a password manager. The toolbar button then
-// opens the approval, and the user answers it there
-// (https://git.eeqj.de/sneak/AutistMask/issues/673).
-//
-// This closes the approval window of request `key` and checks that the page
-// has no answer. It then opens the approval again from the toolbar button.
-// Playwright cannot click that button, so its page is opened in a tab, at the
-// URL the extension put on the button.
-async function closeAndReopen(env, key, view) {
-    const approvalWindow = await waitForApprovalWindow(env.ctx);
-    await visible(approvalWindow, view);
-    await approvalWindow.close();
-
-    const outcome = await settleRequest(env.dapp, key, 2000);
-    assert(
-        outcome.settled === "pending",
-        "closing the approval window answered the page: " +
-            JSON.stringify(outcome),
-    );
-
-    const url = await toolbarPopupUrl(env);
-    assert(
-        url.includes("?approval="),
-        "the toolbar button does not open the pending approval: " + url,
-    );
-    const reopened = await env.ctx.newPage();
-    await reopened.goto(url);
-    await visible(reopened, view);
-    return reopened;
-}
-
-// The stub node answers every nonce request with 0, and the wallet refuses a
-// nonce it has already broadcast. A run can therefore approve one dApp
-// transaction only, so here the signature is approved and the transaction
-// rejected.
-test("a closed signature approval is signed from the toolbar button (#673)", async (env) => {
-    await startRequest(env.dapp, "sign-closed", "personal_sign", [
-        SIGN_HEX,
-        env.expectedAddress,
-    ]);
-    const popup = await closeAndReopen(
-        env,
-        "sign-closed",
-        "#view-approve-sign",
-    );
-    let outcome;
-    try {
-        await popup.fill("#approve-sign-password", PASSWORD);
-        await clickAndClose(popup, "#btn-approve-sign");
-        outcome = await settleRequest(env.dapp, "sign-closed");
-    } finally {
-        await closeApprovalPages(env.ctx);
-    }
-    assert(
-        outcome.settled === "resolved",
-        "personal_sign did not resolve: " + JSON.stringify(outcome),
-    );
-    const recovered = getAddress(
-        verifyMessage(getBytes(SIGN_HEX), outcome.result),
-    );
-    assert(
-        recovered === env.expectedAddress,
-        "the personal_sign signature recovers to " +
-            recovered +
-            ", not to the approved address " +
-            env.expectedAddress,
-    );
-
-    const url = await toolbarPopupUrl(env);
-    assert(
-        !url.includes("?approval="),
-        "the toolbar button still opens the answered approval: " + url,
-    );
-});
-
-test("a closed transaction approval is rejected from the toolbar button (#673)", async (env) => {
-    const before = env.routeOpts.broadcastTransactions.length;
-    await startRequest(env.dapp, "tx-closed", "eth_sendTransaction", [
-        {
-            from: env.expectedAddress,
-            to: STUB_COUNTERPARTY,
-            value: toQuantity(TX_VALUE_WEI),
-            data: TX_DATA,
-        },
-    ]);
-    const popup = await closeAndReopen(env, "tx-closed", "#view-approve-tx");
-    try {
-        await clickAndClose(popup, "#btn-reject-tx");
-        await assertUserRejection(
-            env.dapp,
-            "tx-closed",
-            "the transaction rejected from the toolbar button",
-        );
-    } finally {
-        await closeApprovalPages(env.ctx);
-    }
-    assert(
-        env.routeOpts.broadcastTransactions.length === before,
-        "a rejected transaction still reached the RPC",
-    );
-
-    const url = await toolbarPopupUrl(env);
-    assert(
-        !url.includes("?approval="),
-        "the toolbar button still opens the answered approval: " + url,
-    );
-});
-
 // The extension used to centre every approval window on the last focused
 // window. Centred on another approval window, the new one landed where the
 // browser refused to create it, and the request failed with no window at all
@@ -5188,8 +5070,8 @@ test("a prompt raised while another approval window has focus opens its own (#29
     });
     await visible(txWindow, "#view-approve-tx");
 
-    await clickAndClose(txWindow, "#btn-reject-tx");
-    await clickAndClose(signWindow, "#btn-reject-sign");
+    // Closing a window is refusing its prompt, so both answer 4001.
+    await closeApprovalPages(env.ctx);
     await assertUserRejection(env.dapp, "focus-tx", "the transaction prompt");
     await assertUserRejection(env.dapp, "focus-sign", "the sign prompt");
 });
@@ -5796,11 +5678,9 @@ async function main() {
         // for the new one. After a test that passed, its windows get five
         // seconds to close, and one still open then fails the test: it should
         // have closed itself, and closing it here unreported would hide that.
-        // After a test that already failed, they are closed unreported. That
-        // rejects a site-connection or network-switch prompt it left
-        // unanswered, so the prompt does not refuse the next one from its
-        // site. A transaction or signature approval stays pending, and can
-        // fail the tests after it.
+        // After a test that already failed, they are closed unreported, so
+        // that a prompt it left unanswered does not refuse the next one from
+        // its site.
         if (!failure) {
             const deadline = Date.now() + 5000;
             let open;

tests/fabricatedDecimals.test.js

@@ -111,15 +111,13 @@ function respondWith(items) {
 }
 
 // Fetch and place the result exactly where refreshBalances() places it, so the
-// approval screens read what a real refresh on Ethereum Mainnet would have
-// left on state.
+// approval screens read what a real refresh would have left on state.
 async function fetchOnto(items, trackedTokens = []) {
     respondWith(items);
     const balances = await fetchTokenBalances(
         HOLDER,
         BLOCKSCOUT,
         trackedTokens,
-        "0x1",
     );
     state.trackedTokens = trackedTokens;
     state.wallets = [

tests/firstWalletRefresh.test.js

@@ -48,7 +48,6 @@ async function boot(stored) {
         for (const wallet of wallets) {
             for (const addr of wallet.addresses) addr.balance = chainBalance;
         }
-        return [];
     });
     return { page, refreshBalances };
 }

tests/flashLine.test.js

@@ -88,7 +88,6 @@ describe.each([
             showFlash: (msg) => flashes.push(msg),
             escapeHtml: (s) => s,
             goBack: () => {},
-            trackToken: () => {},
         }));
 
         require("../src/popup/views/" + view).init({

tests/historyAfterNetworkSwitch.test.js

@@ -1,500 +0,0 @@
-// Home, AddressDetail and AddressToken drop a transaction history answer that
-// lands after a network switch. A dropped answer draws no rows and saves no
-// fraud contracts (https://git.eeqj.de/sneak/AutistMask/issues/657).
-//
-// Most tests hold the history request open, switch the network or what the
-// screen shows, and then let the answer land. The views run against a minimal
-// DOM stub, as in tests/transactionListCancelled.test.js, and over
-// tests/support/storageStub.js.
-
-const { makeStorageStub } = require("./support/storageStub");
-const { STATE_SCHEMA_VERSION } = require("../src/shared/stateSchema");
-
-jest.mock("../src/shared/transactions", () => ({
-    ...jest.requireActual("../src/shared/transactions"),
-    fetchRecentTransactions: jest.fn(async () => []),
-}));
-jest.mock("../src/shared/ens", () => ({
-    resolveEnsNames: jest.fn(async () => new Map()),
-}));
-
-const { fetchRecentTransactions } = require("../src/shared/transactions");
-const { resolveEnsNames } = require("../src/shared/ens");
-const { state, loadState } = require("../src/shared/state");
-const { onChainSwitch } = require("../src/shared/chainSwitch");
-const { applyChainSwitchFields } = require("../src/shared/chainSwitchFields");
-const { storedNetworkIs } = require("../src/shared/storedSettings");
-const home = require("../src/popup/views/home");
-const addressDetail = require("../src/popup/views/addressDetail");
-const addressToken = require("../src/popup/views/addressToken");
-
-const ADDRESS = "0x1111111111111111111111111111111111111111";
-const OTHER_ADDRESS = "0x2222222222222222222222222222222222222222";
-const RECIPIENT = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
-// A contract that sends a token claiming USDT's symbol. Spotting the spoof
-// adds this contract to the fraud contracts.
-const SPOOF_CONTRACT = "0x3333333333333333333333333333333333333333";
-const TOKEN = "0x6B175474E89094C44Da98b954EedeAC495271d0F";
-
-// A profile on Ethereum Mainnet with two addresses, "Use Blockscout" on and no
-// fraud contracts.
-function profile() {
-    return {
-        schemaVersion: STATE_SCHEMA_VERSION,
-        hasWallet: true,
-        wallets: [
-            {
-                type: "hd",
-                name: "Main",
-                xpub: "xpub-main",
-                encryptedSecret: "encrypted-secret",
-                nextIndex: 2,
-                addresses: [
-                    { address: ADDRESS, balance: "1.0", tokenBalances: [] },
-                    {
-                        address: OTHER_ADDRESS,
-                        balance: "0.0",
-                        tokenBalances: [],
-                    },
-                ],
-            },
-        ],
-        activeAddress: ADDRESS,
-        networkId: "mainnet",
-        rpcUrl: "https://ethereum-rpc.publicnode.com",
-        blockscoutUrl: "https://eth.blockscout.com/api/v2",
-        useBlockscout: true,
-        fraudContracts: [],
-    };
-}
-
-// What Blockscout answers for ADDRESS on Ethereum Mainnet:
-//
-// - a transfer of ETH from ADDRESS;
-// - a transfer of the fake USDT from SPOOF_CONTRACT.
-function history() {
-    return [
-        {
-            hash: "0x85215772ed26ea8b39c2b3b18779030487efbe0b5fd7e882592b2f62b837be84",
-            blockNumber: 2,
-            from: ADDRESS,
-            to: RECIPIENT,
-            value: "1.0000",
-            exactValue: "1.0",
-            rawAmount: "1000000000000000000",
-            rawUnit: "wei",
-            symbol: "ETH",
-            timestamp: 1790000000,
-            isError: false,
-            directionLabel: "Sent",
-            direction: "sent",
-            contractAddress: null,
-            chainId: "0x1",
-        },
-        {
-            hash: "0x0d6a6e0a0d1b7d4c3b2a19087f6e5d4c3b2a19087f6e5d4c3b2a19087f6e5d4c",
-            blockNumber: 1,
-            from: SPOOF_CONTRACT,
-            to: ADDRESS,
-            value: "100.0000",
-            exactValue: "100.0",
-            rawAmount: "100000000",
-            rawUnit: "base units",
-            symbol: "USDT",
-            timestamp: 1790000000,
-            isError: false,
-            directionLabel: "Received",
-            direction: "received",
-            contractAddress: SPOOF_CONTRACT,
-            chainId: "0x1",
-        },
-    ];
-}
-
-// The next history request waits until the returned function is called, and
-// then answers with `answer`.
-function holdHistory(answer = history()) {
-    let land;
-    fetchRecentTransactions.mockImplementationOnce(
-        () =>
-            new Promise((resolve) => {
-                land = () => resolve(answer);
-            }),
-    );
-    return () => land();
-}
-
-// The next history request waits until the returned function is called, and
-// then fails.
-function holdFailure() {
-    let fail;
-    fetchRecentTransactions.mockImplementationOnce(
-        () =>
-            new Promise((resolve, reject) => {
-                fail = () => reject(new Error("Blockscout is down"));
-            }),
-    );
-    return () => fail();
-}
-
-// Another write holds the lock until the returned function is called. Every
-// save waits until then.
-function holdLock() {
-    let release;
-    const held = navigator.locks.request(
-        "autistmask",
-        () =>
-            new Promise((resolve) => {
-                release = resolve;
-            }),
-    );
-    return async () => {
-        release();
-        await held;
-    };
-}
-
-function makeElement(id) {
-    const el = {
-        id,
-        textContent: "",
-        value: "",
-        innerHTML: "",
-        style: {},
-        dataset: {},
-        classList: {
-            add: () => {},
-            remove: () => {},
-            contains: () => false,
-            toggle: () => false,
-        },
-        addEventListener: () => {},
-        querySelectorAll: () => [],
-        appendChild: () => {},
-    };
-    // Views reach for .parentElement to hide whole sections.
-    Object.defineProperty(el, "parentElement", {
-        get: () => node(id + "-parent"),
-    });
-    return el;
-}
-
-function makeDocument() {
-    const els = new Map();
-    return {
-        getElementById(id) {
-            // The debug banner is created on demand by helpers.js; absent
-            // is the state a non-debug, non-testnet popup is in.
-            if (id === "debug-banner") return null;
-            if (!els.has(id)) els.set(id, makeElement(id));
-            return els.get(id);
-        },
-        createElement: () => makeElement("created"),
-        addEventListener: () => {},
-        body: { prepend: () => {} },
-    };
-}
-
-function node(id) {
-    return globalThis.document.getElementById(id);
-}
-
-// Lets every promise that is not held open settle.
-function settle() {
-    return new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-let storage;
-
-beforeEach(async () => {
-    storage = makeStorageStub({ autistmask: profile() });
-    globalThis.chrome = {
-        storage: { local: storage.local, onChanged: storage.onChanged },
-    };
-    globalThis.document = makeDocument();
-    globalThis.window = { location: { search: "" } };
-    await loadState();
-    state.viewStack = [];
-    state.selectedWallet = 0;
-    state.selectedAddress = 0;
-    state.selectedToken = "ETH";
-    const ctx = { pageClosed: new AbortController().signal };
-    addressDetail.init(ctx);
-    addressToken.init(ctx);
-});
-
-afterEach(() => {
-    delete globalThis.chrome;
-    delete globalThis.document;
-    delete globalThis.window;
-});
-
-const HOME = {
-    name: "Home",
-    listId: "home-tx-list",
-    open: () => home.render({ pageClosed: new AbortController().signal }),
-};
-const ADDRESS_DETAIL = {
-    name: "AddressDetail",
-    listId: "tx-list",
-    open: () => addressDetail.show(),
-};
-const ADDRESS_TOKEN = {
-    name: "AddressToken",
-    listId: "address-token-tx-list",
-    open: () => addressToken.show(),
-};
-
-// Three ways a test switches the network:
-//
-// - made in Settings: the page and storage have both switched;
-// - saved elsewhere: storage has switched and the page has not;
-// - not yet stored: the page has switched and storage has not.
-const SWITCHES = [
-    {
-        how: "made in Settings",
-        to: (networkId) => onChainSwitch(networkId),
-    },
-    {
-        // Another page or the background stored the switch, and this page has
-        // not followed it yet.
-        how: "saved elsewhere",
-        to: async (networkId) => {
-            const record = storage.read("autistmask");
-            applyChainSwitchFields(record, networkId);
-            storage.write("autistmask", record);
-        },
-    },
-    {
-        // The switch's own save has changed the page and has not yet written
-        // storage.
-        how: "not yet stored",
-        to: async (networkId) => {
-            applyChainSwitchFields(state, networkId);
-        },
-    },
-];
-
-// The list still shows `before`, and neither the page nor storage holds a
-// fraud contract.
-function expectNothingAdded(screen, before) {
-    expect(node(screen.listId).innerHTML).toBe(before);
-    expect(state.fraudContracts).toEqual([]);
-    expect(storage.read("autistmask").fraudContracts).toEqual([]);
-}
-
-describe.each([HOME, ADDRESS_DETAIL, ADDRESS_TOKEN])("$name", (screen) => {
-    test("an answer that lands on the same network is drawn and saved", async () => {
-        const land = holdHistory();
-        screen.open();
-        land();
-        await settle();
-
-        expect(node(screen.listId).innerHTML).toContain("tx-row");
-        expect(state.fraudContracts).toEqual([SPOOF_CONTRACT]);
-        expect(storage.read("autistmask").fraudContracts).toEqual([
-            SPOOF_CONTRACT,
-        ]);
-    });
-
-    test.each(SWITCHES)(
-        "an answer that lands after a switch $how adds nothing",
-        async ({ to }) => {
-            const land = holdHistory();
-            screen.open();
-            await settle();
-            const before = node(screen.listId).innerHTML;
-            await to("sepolia");
-            land();
-            await settle();
-
-            expectNothingAdded(screen, before);
-        },
-    );
-
-    // The answer is the transfer of ETH alone, which adds no fraud contract.
-    // Nothing is saved, so only the check before the save can drop the answer.
-    test.each(SWITCHES)(
-        "an answer without a fraud contract that lands after a switch $how adds nothing",
-        async ({ to }) => {
-            const land = holdHistory(history().slice(0, 1));
-            screen.open();
-            await settle();
-            const before = node(screen.listId).innerHTML;
-            await to("sepolia");
-            land();
-            await settle();
-
-            expectNothingAdded(screen, before);
-        },
-    );
-
-    test.each(SWITCHES)(
-        "a request that fails after a switch $how shows no message",
-        async ({ to }) => {
-            const fail = holdFailure();
-            screen.open();
-            await settle();
-            const before = node(screen.listId).innerHTML;
-            await to("sepolia");
-            fail();
-            await settle();
-
-            expect(node(screen.listId).innerHTML).toBe(before);
-        },
-    );
-
-    // The user picks Sepolia in Settings while another write holds the lock.
-    // The answer lands, and its save waits behind the switch.
-    test("an answer whose save waits behind a switch made in Settings adds nothing", async () => {
-        const land = holdHistory();
-        screen.open();
-        const before = node(screen.listId).innerHTML;
-        const releaseLock = holdLock();
-        const switching = onChainSwitch("sepolia");
-        land();
-        await settle();
-        await releaseLock();
-        await switching;
-        await settle();
-
-        expectNothingAdded(screen, before);
-    });
-
-    // The answer lands and its save waits for the lock. Another page or the
-    // background then stores a switch.
-    test("an answer whose save waits while a switch is saved elsewhere adds nothing", async () => {
-        const land = holdHistory();
-        screen.open();
-        const before = node(screen.listId).innerHTML;
-        const releaseLock = holdLock();
-        land();
-        await settle();
-        const record = storage.read("autistmask");
-        applyChainSwitchFields(record, "sepolia");
-        storage.write("autistmask", record);
-        await releaseLock();
-        await settle();
-
-        expectNothingAdded(screen, before);
-    });
-
-    // The answer lands and its save waits for the lock. The page then switches,
-    // and storage has not.
-    test("an answer whose save waits while the page switches adds nothing", async () => {
-        const land = holdHistory();
-        screen.open();
-        const before = node(screen.listId).innerHTML;
-        const releaseLock = holdLock();
-        land();
-        await settle();
-        applyChainSwitchFields(state, "sepolia");
-        await releaseLock();
-        await settle();
-
-        expectNothingAdded(screen, before);
-    });
-
-    test("a request that fails after a switch leaves the new network's rows", async () => {
-        const fail = holdFailure();
-        screen.open();
-        await onChainSwitch("sepolia");
-        fetchRecentTransactions.mockImplementationOnce(async () => history());
-        screen.open();
-        await settle();
-        const drawn = node(screen.listId).innerHTML;
-        fail();
-        await settle();
-
-        expect(drawn).toContain("tx-row");
-        expect(node(screen.listId).innerHTML).toBe(drawn);
-    });
-});
-
-describe.each([ADDRESS_DETAIL, ADDRESS_TOKEN])("$name", (screen) => {
-    test("an answer that lands once the screen shows another address adds nothing", async () => {
-        const land = holdHistory();
-        screen.open();
-        state.selectedAddress = 1;
-        screen.open();
-        await settle();
-        const before = node(screen.listId).innerHTML;
-        land();
-        await settle();
-
-        expectNothingAdded(screen, before);
-    });
-
-    test("a request that fails once the screen shows another address shows no message", async () => {
-        const fail = holdFailure();
-        screen.open();
-        state.selectedAddress = 1;
-        screen.open();
-        await settle();
-        const before = node(screen.listId).innerHTML;
-        fail();
-        await settle();
-
-        expect(node(screen.listId).innerHTML).toBe(before);
-    });
-
-    // The answer is the transfer of ETH alone, which adds no fraud contract.
-    // Nothing is saved, so only the check after the name lookup can drop the
-    // answer.
-    test("an answer whose name lookup lands after a switch adds nothing", async () => {
-        let landNames;
-        resolveEnsNames.mockImplementationOnce(
-            () =>
-                new Promise((resolve) => {
-                    landNames = () => resolve(new Map());
-                }),
-        );
-        fetchRecentTransactions.mockImplementationOnce(async () =>
-            history().slice(0, 1),
-        );
-        screen.open();
-        await settle();
-        const before = node(screen.listId).innerHTML;
-        await onChainSwitch("sepolia");
-        landNames();
-        await settle();
-
-        expectNothingAdded(screen, before);
-    });
-});
-
-test("AddressToken: an answer that lands once the screen shows another token adds nothing", async () => {
-    const land = holdHistory();
-    addressToken.show();
-    state.selectedToken = TOKEN;
-    addressToken.show();
-    await settle();
-    const before = node(ADDRESS_TOKEN.listId).innerHTML;
-    land();
-    await settle();
-
-    expectNothingAdded(ADDRESS_TOKEN, before);
-});
-
-test("AddressToken: a request that fails once the screen shows another token shows no message", async () => {
-    const fail = holdFailure();
-    addressToken.show();
-    state.selectedToken = TOKEN;
-    addressToken.show();
-    await settle();
-    const before = node(ADDRESS_TOKEN.listId).innerHTML;
-    fail();
-    await settle();
-
-    expect(node(ADDRESS_TOKEN.listId).innerHTML).toBe(before);
-});
-
-test("storedNetworkIs(): a failed read counts as no", async () => {
-    globalThis.chrome.storage.local = {
-        get: async () => {
-            throw new Error("storage is down");
-        },
-    };
-
-    await expect(storedNetworkIs("mainnet")).resolves.toBe(false);
-});

tests/holders.test.js

@@ -192,13 +192,7 @@ describe("the balance-list spam gate", () => {
                 },
             }),
         ]);
-        // On Ethereum Mainnet, the only network the known-token list covers.
-        const balances = await fetchTokenBalances(
-            HOLDER,
-            BLOCKSCOUT,
-            [],
-            "0x1",
-        );
+        const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, []);
         expect(balances).toHaveLength(1);
         expect(balances[0].holders).toBeNull();
     });

tests/manifest.test.js

@@ -169,7 +169,7 @@ describe("declared icons", () => {
 // save could land between the background's read and its write (README,
 // "Stored state and its version").
 describe("private windows", () => {
-    test("a page in a firefox private window cannot read or write extension storage", () => {
+    test("firefox never runs AutistMask in a private window", () => {
         expect(readManifest("firefox").incognito).toBe("not_allowed");
     });
 });

tests/popupFollowsNetworkSwitch.test.js

@@ -253,271 +253,6 @@ test("a switch back in Settings after a follow whose write failed is stored", as
     expect(told.at(-1).chainId).toBe(NETWORKS.mainnet.chainId);
 });
 
-// The user saves an endpoint URL in Settings on Ethereum Mainnet. Before the
-// URL is stored, the background saves a switch to Sepolia. Another write holds
-// the lock, so the popup's follow of that switch and the URL's save both wait
-// for the lock. Either may take it first. The URL is stored for neither
-// network. The flash message says that the network changed.
-test.each([
-    { button: "btn-save-rpc", field: "settings-rpc", first: "follow" },
-    { button: "btn-save-rpc", field: "settings-rpc", first: "save" },
-    {
-        button: "btn-save-blockscout",
-        field: "settings-blockscout",
-        first: "follow",
-    },
-    {
-        button: "btn-save-blockscout",
-        field: "settings-blockscout",
-        first: "save",
-    },
-])(
-    "$button saves nothing when the network changes before the URL is stored ($first first)",
-    async ({ button, field, first }) => {
-        const page = await bootOnAddress();
-        await page.click("btn-settings");
-        // This answer passes both endpoint checks. The RPC check reads
-        // Ethereum Mainnet's chain id from it. The Blockscout check reads `ok`.
-        globalThis.fetch.mockResolvedValue({
-            ok: true,
-            json: async () => ({ result: NETWORKS.mainnet.chainId }),
-        });
-        const url = "https://own-node.example.invalid";
-
-        let releaseLock;
-        const lockHeld = navigator.locks.request(
-            "autistmask",
-            () =>
-                new Promise((resolve) => {
-                    releaseLock = resolve;
-                }),
-        );
-        // The click handler runs until its save waits for the lock.
-        const tapSave = async () => {
-            page.node(field).value = url;
-            const saving = page.node(button).listeners.click.map((fn) => fn());
-            await page.settle();
-            return saving;
-        };
-        let saving;
-        if (first === "save") saving = await tapSave();
-        await backgroundSwitch(page, "sepolia");
-        if (first === "follow") saving = await tapSave();
-        releaseLock();
-        await lockHeld;
-        await Promise.all(saving);
-        await page.settle();
-
-        const { state } = require("../src/shared/state");
-        expect(state.networkId).toBe("sepolia");
-        expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(
-            url,
-        );
-        expect(page.text("flash-msg")).toBe(
-            "The URL was not saved because the network changed.",
-        );
-    },
-);
-
-// The popup's follow of the background's switch to Sepolia has set `state` to
-// Sepolia. The follow's write has not returned yet, so Settings still shows
-// Ethereum Mainnet. The user taps "Save" there. The URL is for Ethereum
-// Mainnet, so the save stores the URL for neither network.
-test.each([
-    { button: "btn-save-rpc", field: "settings-rpc" },
-    { button: "btn-save-blockscout", field: "settings-blockscout" },
-])(
-    "$button saves nothing when tapped while the follow's write waits",
-    async ({ button, field }) => {
-        const page = await bootOnAddress();
-        await page.click("btn-settings");
-        // This answer passes both endpoint checks on Ethereum Mainnet.
-        globalThis.fetch.mockResolvedValue({
-            ok: true,
-            json: async () => ({ result: NETWORKS.mainnet.chainId }),
-        });
-        const url = "https://own-node.example.invalid";
-
-        const { set } = page.storage.local;
-        const write = set.getMockImplementation();
-        let releaseWrite;
-        const writeHeld = new Promise((resolve) => {
-            releaseWrite = resolve;
-        });
-        // The background's write lands; the next, the follow's, waits.
-        set.mockImplementationOnce(write).mockImplementationOnce(
-            async (items) => {
-                await writeHeld;
-                await write(items);
-            },
-        );
-        await backgroundSwitch(page, "sepolia");
-        const { state } = require("../src/shared/state");
-        expect(state.networkId).toBe("sepolia");
-        expect(page.value("settings-network")).toBe("mainnet");
-
-        page.node(field).value = url;
-        const saving = page.node(button).listeners.click.map((fn) => fn());
-        await page.settle();
-        releaseWrite();
-        await Promise.all(saving);
-        await page.settle();
-
-        expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(
-            url,
-        );
-        expect(page.text("flash-msg")).toBe(
-            "The URL was not saved because the network changed.",
-        );
-    },
-);
-
-// The user taps the RPC "Save" on Ethereum Mainnet. While the check waits for
-// the node's answer, the popup follows the background's switch to Sepolia. The
-// node answers with Sepolia's chain id. So the check refuses the node for
-// Ethereum Mainnet, and nothing is stored.
-test("the RPC check compares the answer with the network at the tap", async () => {
-    const page = await bootOnAddress();
-    await page.click("btn-settings");
-    let answer;
-    globalThis.fetch.mockReturnValue(
-        new Promise((resolve) => {
-            answer = resolve;
-        }),
-    );
-    const url = "https://sepolia-node.example.invalid";
-
-    page.node("settings-rpc").value = url;
-    const saving = page.node("btn-save-rpc").listeners.click.map((fn) => fn());
-    await page.settle();
-    await backgroundSwitch(page, "sepolia");
-    const { state } = require("../src/shared/state");
-    expect(state.networkId).toBe("sepolia");
-    answer({ json: async () => ({ result: NETWORKS.sepolia.chainId }) });
-    await Promise.all(saving);
-    await page.settle();
-
-    expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(url);
-    expect(page.text("flash-msg")).toBe(
-        "Wrong network: expected Ethereum Mainnet.",
-    );
-});
-
-// The user taps the Blockscout "Save" on Ethereum Mainnet. While the check
-// waits for Blockscout's answer, the popup follows the background's switch to
-// Sepolia. The URL is for Ethereum Mainnet, so nothing is stored.
-test("the Blockscout save is for the network at the tap", async () => {
-    const page = await bootOnAddress();
-    await page.click("btn-settings");
-    let answer;
-    globalThis.fetch.mockReturnValue(
-        new Promise((resolve) => {
-            answer = resolve;
-        }),
-    );
-    const url = "https://own-explorer.example.invalid/api/v2";
-
-    page.node("settings-blockscout").value = url;
-    const saving = page
-        .node("btn-save-blockscout")
-        .listeners.click.map((fn) => fn());
-    await page.settle();
-    await backgroundSwitch(page, "sepolia");
-    expect(page.value("settings-network")).toBe("sepolia");
-    answer({ ok: true });
-    await Promise.all(saving);
-    await page.settle();
-
-    expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(url);
-    expect(page.text("flash-msg")).toBe(
-        "The URL was not saved because the network changed.",
-    );
-});
-
-// Settings is open when the network changes to Sepolia. The popup follows the
-// background's switch, or the user picks Sepolia in the network selector. Each
-// "Save" after the switch stores its URL for Sepolia.
-test.each([
-    ["a follow", (page) => backgroundSwitch(page, "sepolia")],
-    [
-        "the network selector",
-        async (page) => {
-            const select = page.node("settings-network");
-            select.value = "sepolia";
-            for (const fn of select.listeners.change) await fn();
-            await page.settle();
-        },
-    ],
-])(
-    "after a switch to Sepolia by %s, Settings saves each URL for Sepolia",
-    async (_how, switchToSepolia) => {
-        const page = await bootOnAddress();
-        await page.click("btn-settings");
-        await switchToSepolia(page);
-        // This answer passes both endpoint checks on Sepolia. The RPC check
-        // reads Sepolia's chain id from it. The Blockscout check reads `ok`.
-        globalThis.fetch.mockResolvedValue({
-            ok: true,
-            json: async () => ({ result: NETWORKS.sepolia.chainId }),
-        });
-        const rpcUrl = "https://own-node.example.invalid";
-        const blockscoutUrl = "https://own-explorer.example.invalid/api/v2";
-
-        page.node("settings-rpc").value = rpcUrl;
-        await page.click("btn-save-rpc");
-        expect(page.text("flash-msg")).toBe("Saved.");
-        page.node("settings-blockscout").value = blockscoutUrl;
-        await page.click("btn-save-blockscout");
-        expect(page.text("flash-msg")).toBe("Saved.");
-
-        const stored = page.storage.read("autistmask");
-        expect(stored.networkId).toBe("sepolia");
-        expect(stored.rpcUrl).toBe(rpcUrl);
-        expect(stored.blockscoutUrl).toBe(blockscoutUrl);
-    },
-);
-
-// The user picks Sepolia in Settings, but the switch's write fails. The page is
-// then on Sepolia, while Settings was last drawn for Ethereum Mainnet. A "Save"
-// after the failed switch stores nothing for either network.
-test.each([
-    { button: "btn-save-rpc", field: "settings-rpc" },
-    { button: "btn-save-blockscout", field: "settings-blockscout" },
-])(
-    "$button saves nothing after a switch in Settings whose write failed",
-    async ({ button, field }) => {
-        const page = await bootOnAddress();
-        await page.click("btn-settings");
-        page.storage.local.set.mockRejectedValueOnce(
-            new Error("quota exceeded"),
-        );
-        const select = page.node("settings-network");
-        select.value = "sepolia";
-        for (const fn of select.listeners.change) {
-            await expect(fn()).rejects.toThrow("quota exceeded");
-        }
-        await page.settle();
-        const { state } = require("../src/shared/state");
-        expect(state.networkId).toBe("sepolia");
-        // This answer passes both endpoint checks on Ethereum Mainnet.
-        globalThis.fetch.mockResolvedValue({
-            ok: true,
-            json: async () => ({ result: NETWORKS.mainnet.chainId }),
-        });
-        const url = "https://own-node.example.invalid";
-
-        page.node(field).value = url;
-        await page.click(button);
-
-        expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(
-            url,
-        );
-        expect(page.text("flash-msg")).toBe(
-            "The URL was not saved because the network changed.",
-        );
-    },
-);
-
 // Such as one a newer build wrote, which this build cannot read. Nothing reads
 // or writes the stored record for it: the popup's next save finds it, as
 // before.

tests/priceFeeds.test.js

@@ -1,272 +0,0 @@
-// USD prices are read from Chainlink price feeds on mainnet, through the RPC
-// endpoint (https://git.eeqj.de/sneak/AutistMask/issues/525).
-//
-// The real refreshPrices() runs against a fake JSON-RPC node, answered through
-// ethers' own request hook. The hook also records the body of every HTTP
-// request, so a test can count them.
-
-// prices.js pulls in state.js, which reads chrome.storage.local at load.
-globalThis.chrome = {
-    storage: { local: { get: async () => ({}), set: async () => {} } },
-};
-
-const { AbiCoder, FetchRequest } = require("ethers");
-const {
-    prices,
-    refreshPrices,
-    clearPrices,
-    getPrice,
-    getAddressValue,
-} = require("../src/shared/prices");
-const { state } = require("../src/shared/state");
-const {
-    TOKENS,
-    ETH_USD_FEED,
-    USD_PRICE_FEEDS,
-    PRICE_FEED_BY_ADDRESS,
-} = require("../src/shared/tokenList");
-
-const RPC_URL = "https://rpc.example.invalid";
-const NOW = Date.UTC(2026, 9, 27, 12, 0, 0);
-const NOW_SECONDS = NOW / 1000;
-
-const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
-const LINK = "0x514910771af9ca656af840dff83e8264ecf986ca";
-const DAI = "0x6b175474e89094c44da98b954eedeac495271d0f";
-// A token at an address of its own that calls itself USDC.
-const FAKE_USDC = "0x9999999999999999999999999999999999999999";
-
-const ETH_FEED = ETH_USD_FEED.address.toLowerCase();
-const USDC_FEED = PRICE_FEED_BY_ADDRESS.get(USDC).address.toLowerCase();
-const LINK_FEED = PRICE_FEED_BY_ADDRESS.get(LINK).address.toLowerCase();
-const DAI_FEED = PRICE_FEED_BY_ADDRESS.get(DAI).address.toLowerCase();
-
-// What each feed answers, by its lowercased address: the price in the feed's
-// own units and the time it was written. A feed that is not here makes the
-// call fail.
-let rounds;
-// The parsed body of every HTTP request the node received.
-let requests;
-let logged;
-
-function round(answer, updatedAt = NOW_SECONDS) {
-    return { answer, updatedAt };
-}
-
-// One JSON-RPC answer, to a latestRoundData() call.
-function reply(req) {
-    const envelope = { jsonrpc: "2.0", id: req.id };
-    const answer = rounds[req.params[0].to.toLowerCase()];
-    if (!answer) {
-        return {
-            ...envelope,
-            error: { code: -32000, message: "fixture: read failed" },
-        };
-    }
-    return {
-        ...envelope,
-        result: AbiCoder.defaultAbiCoder().encode(
-            ["uint80", "int256", "uint256", "uint256", "uint80"],
-            [1, answer.answer, answer.updatedAt, answer.updatedAt, 1],
-        ),
-    };
-}
-
-// The feed addresses one HTTP request read, sorted.
-function feedsRead(body) {
-    return [body]
-        .flat()
-        .map((req) => req.params[0].to.toLowerCase())
-        .sort();
-}
-
-// One address that holds `held`, a list of [contract address, symbol].
-function holdTokens(held) {
-    state.wallets = [
-        {
-            addresses: [
-                {
-                    address: "0x" + "a".repeat(40),
-                    balance: "1.0",
-                    tokenBalances: held.map(([address, symbol]) => ({
-                        address,
-                        symbol,
-                        balance: "10.0",
-                    })),
-                },
-            ],
-        },
-    ];
-}
-
-beforeEach(() => {
-    clearPrices();
-    state.networkId = "mainnet";
-    state.rpcUrl = RPC_URL;
-    state.wallets = [];
-    state.trackedTokens = [];
-    rounds = { [ETH_FEED]: round(2000n * 10n ** 8n) };
-    requests = [];
-    logged = [];
-    jest.spyOn(Date, "now").mockReturnValue(NOW);
-    for (const level of ["error", "warn"]) {
-        jest.spyOn(console, level).mockImplementation((...args) => {
-            logged.push(args.map(String).join(" "));
-        });
-    }
-    FetchRequest.registerGetUrl(async (req) => {
-        const body = JSON.parse(Buffer.from(req.body).toString("utf8"));
-        requests.push(body);
-        const answer = Array.isArray(body) ? body.map(reply) : reply(body);
-        return {
-            statusCode: 200,
-            statusMessage: "OK",
-            headers: { "content-type": "application/json" },
-            body: Buffer.from(JSON.stringify(answer)),
-        };
-    });
-});
-
-afterEach(() => {
-    FetchRequest.registerGetUrl(FetchRequest.createGetUrlFunc());
-    jest.restoreAllMocks();
-    clearPrices();
-});
-
-describe("refreshPrices", () => {
-    test("reads ETH and each held or tracked token that has a feed in one HTTP request", async () => {
-        holdTokens([
-            [USDC, "USDC"],
-            [LINK, "LINK"],
-        ]);
-        state.trackedTokens = [{ address: DAI, symbol: "DAI", decimals: 18 }];
-        rounds[USDC_FEED] = round(10n ** 8n);
-        rounds[LINK_FEED] = round(1150000000n);
-        rounds[DAI_FEED] = round(99990000n);
-
-        await refreshPrices();
-
-        expect(requests).toHaveLength(1);
-        expect(feedsRead(requests[0])).toEqual(
-            [ETH_FEED, USDC_FEED, LINK_FEED, DAI_FEED].sort(),
-        );
-        expect(getPrice("ETH")).toBe(2000);
-        expect(getPrice(USDC)).toBe(1);
-        expect(getPrice(LINK)).toBe(11.5);
-        expect(getPrice(DAI)).toBe(0.9999);
-    });
-
-    test("reads again only once 5 minutes have passed", async () => {
-        await refreshPrices();
-        Date.now.mockReturnValue(NOW + 299999);
-        await refreshPrices();
-        expect(requests).toHaveLength(1);
-
-        Date.now.mockReturnValue(NOW + 300000);
-        rounds[ETH_FEED] = round(2100n * 10n ** 8n, NOW_SECONDS + 300);
-        await refreshPrices();
-        expect(requests).toHaveLength(2);
-        expect(getPrice("ETH")).toBe(2100);
-    });
-
-    test("on Sepolia, reads nothing and keeps no price", async () => {
-        await refreshPrices();
-        expect(getPrice("ETH")).toBe(2000);
-
-        state.networkId = "sepolia";
-        await refreshPrices();
-        expect(requests).toHaveLength(1);
-        expect(Object.keys(prices)).toEqual([]);
-    });
-});
-
-describe("pairing by contract address", () => {
-    test("a token that copies a bundled token's symbol gets no price", async () => {
-        holdTokens([
-            [USDC, "USDC"],
-            [FAKE_USDC, "USDC"],
-        ]);
-        rounds[USDC_FEED] = round(10n ** 8n);
-
-        await refreshPrices();
-
-        expect(feedsRead(requests[0])).toEqual([ETH_FEED, USDC_FEED].sort());
-        expect(getPrice(USDC)).toBe(1);
-        expect(getPrice(FAKE_USDC)).toBeNull();
-        // 1 ETH and 10 real USDC are priced; the 10 look-alikes are not.
-        expect(getAddressValue(state.wallets[0].addresses[0])).toEqual({
-            usd: 2010,
-            partial: true,
-        });
-    });
-});
-
-describe("freshness", () => {
-    test("a reading older than its feed's heartbeat plus 30 minutes is no price", async () => {
-        const heartbeatAgo =
-            NOW_SECONDS - PRICE_FEED_BY_ADDRESS.get(USDC).heartbeat;
-        holdTokens([[USDC, "USDC"]]);
-
-        rounds[USDC_FEED] = round(10n ** 8n, heartbeatAgo - 1800 - 1);
-        await refreshPrices();
-        expect(getPrice(USDC)).toBeNull();
-
-        clearPrices();
-        rounds[USDC_FEED] = round(10n ** 8n, heartbeatAgo - 1800);
-        await refreshPrices();
-        expect(getPrice(USDC)).toBe(1);
-    });
-
-    test.each([0n, -1n])("an answer of %s is no price", async (answer) => {
-        rounds[ETH_FEED] = round(answer);
-        await refreshPrices();
-        expect(getPrice("ETH")).toBeNull();
-    });
-});
-
-describe("a failed read", () => {
-    test("leaves the token with no price and is logged with its error", async () => {
-        holdTokens([[USDC, "USDC"]]);
-        rounds[USDC_FEED] = round(10n ** 8n);
-        await refreshPrices();
-        expect(getPrice(USDC)).toBe(1);
-
-        Date.now.mockReturnValue(NOW + 300000);
-        delete rounds[USDC_FEED];
-        await refreshPrices();
-
-        expect(getPrice(USDC)).toBeNull();
-        expect(getPrice("ETH")).toBe(2000);
-        expect(
-            logged.some(
-                (line) =>
-                    line.includes("price feed read failed") &&
-                    line.includes(USDC),
-            ),
-        ).toBe(true);
-    });
-
-    test("an HTTP error is logged with its status", async () => {
-        FetchRequest.registerGetUrl(async () => ({
-            statusCode: 401,
-            statusMessage: "Unauthorized",
-            headers: { "content-type": "text/plain" },
-            body: Buffer.from("API key required"),
-        }));
-
-        await refreshPrices();
-
-        expect(getPrice("ETH")).toBeNull();
-        expect(logged.some((line) => line.includes("401"))).toBe(true);
-    });
-});
-
-describe("the feed table", () => {
-    test("names each token by its address as the bundled list spells it", () => {
-        const listed = new Set(TOKENS.map((t) => t.address));
-        const unlisted = Object.keys(USD_PRICE_FEEDS).filter(
-            (address) => !listed.has(address),
-        );
-        expect(unlisted).toEqual([]);
-    });
-});

tests/refreshDuringRefresh.test.js

@@ -1,157 +0,0 @@
-// While a refresh runs, a request through ctx is not dropped. One more refresh
-// runs once the running one ends, however many were asked for in that time
-// (https://git.eeqj.de/sneak/AutistMask/issues/581). A tick of the ten-second
-// timer that finds a refresh running is dropped. Each test boots the real popup
-// over a stored profile and holds the ten-second refresh open. `readChain()`
-// sets each address's balance from `CHAIN`, as the real `refreshBalances()`
-// sets it from the node.
-
-const {
-    bootPopup,
-    cleanupPopup,
-    unversionedValidProfile,
-    ADDRESS,
-} = require("./support/popupBoot");
-const {
-    hdWalletFromMnemonic,
-    deriveAddressFromXpub,
-} = require("../src/shared/wallet");
-
-const PHRASE =
-    "abandon abandon abandon abandon abandon abandon " +
-    "abandon abandon abandon abandon abandon about";
-const PASSWORD = "correct horse battery staple";
-
-// The first two addresses of PHRASE, both used on the chain.
-const { xpub, firstAddress } = hdWalletFromMnemonic(PHRASE);
-const SECOND_ADDRESS = deriveAddressFromXpub(xpub, 1);
-
-// The ETH balance the chain holds for each address, in ether.
-const CHAIN = {
-    [ADDRESS]: "1.5",
-    [firstAddress]: "2.0",
-    [SECOND_ADDRESS]: "3.0",
-};
-
-afterEach(() => {
-    cleanupPopup();
-});
-
-// The balance stand-in for a refresh that returns.
-async function readChain(wallets) {
-    for (const wallet of wallets) {
-        for (const addr of wallet.addresses) {
-            addr.balance = CHAIN[addr.address];
-        }
-    }
-}
-
-// Boots the popup over a profile with one wallet. From then on,
-// `refreshBalances()` never returns unless the test answers it. So an unwanted
-// refresh is counted once and then waits, instead of starting more.
-async function boot() {
-    const page = await bootPopup(unversionedValidProfile());
-    expect(page.pageErrors).toEqual([]);
-    const { refreshBalances } = require("../src/shared/balances");
-    refreshBalances.mockImplementation(() => new Promise(() => {}));
-    return { page, refreshBalances };
-}
-
-// Starts the ten-second refresh and holds it open until finish() is called.
-// The held refresh then writes the chain's balances. finish() resolves once
-// the held refresh has saved them and drawn Home. The one refresh after the
-// held one also returns.
-async function holdRefresh(page) {
-    const { refreshBalances } = require("../src/shared/balances");
-    let answer;
-    refreshBalances
-        .mockImplementationOnce(async (wallets) => {
-            await new Promise((resolve) => {
-                answer = resolve;
-            });
-            await readChain(wallets);
-        })
-        .mockImplementationOnce(readChain);
-    const ticking = page.tick();
-    await page.settle();
-    return {
-        finish: async () => {
-            answer();
-            await ticking;
-        },
-    };
-}
-
-// Imports PHRASE on AddWallet. Its address scan finds the phrase's first two
-// addresses.
-async function importPhrase(page) {
-    const { scanForAddresses } = require("../src/shared/balances");
-    scanForAddresses.mockImplementationOnce(async () => ({
-        addresses: [
-            { address: firstAddress, index: 0 },
-            { address: SECOND_ADDRESS, index: 1 },
-        ],
-        nextIndex: 2,
-    }));
-    await page.click("btn-add-wallet-bottom");
-    await page.click("tab-mnemonic");
-    page.node("wallet-mnemonic").value = PHRASE;
-    page.node("add-wallet-password").value = PASSWORD;
-    page.node("add-wallet-password-confirm").value = PASSWORD;
-    await page.click("btn-add-wallet-confirm");
-}
-
-// Imports the private key `key` on AddWallet.
-async function importKey(page, key) {
-    await page.click("btn-add-wallet-bottom");
-    await page.click("tab-privkey");
-    page.node("import-private-key").value = key;
-    page.node("add-wallet-password").value = PASSWORD;
-    page.node("add-wallet-password-confirm").value = PASSWORD;
-    await page.click("btn-add-wallet-confirm");
-}
-
-test("addresses that an import finds during a refresh show their balances once one more refresh returns", async () => {
-    const { page } = await boot();
-    const refresh = await holdRefresh(page);
-
-    await importPhrase(page);
-    expect(page.visibleViews()).toEqual(["main"]);
-    expect(page.text("flash-msg")).toBe("Found 2 addresses.");
-
-    await refresh.finish();
-    await page.settle();
-
-    const list = page.node("wallet-list").innerHTML;
-    expect(list).toContain("<span>2.0000</span>");
-    expect(list).toContain("<span>3.0000</span>");
-});
-
-test("several requests during a refresh lead to exactly one more refresh", async () => {
-    const { page, refreshBalances } = await boot();
-    const refresh = await holdRefresh(page);
-    const calls = refreshBalances.mock.calls.length;
-
-    await importKey(page, "0x" + "11".repeat(32));
-    await importKey(page, "0x" + "22".repeat(32));
-    await importPhrase(page);
-    expect(refreshBalances).toHaveBeenCalledTimes(calls);
-
-    await refresh.finish();
-    await page.settle();
-
-    expect(refreshBalances).toHaveBeenCalledTimes(calls + 1);
-});
-
-test("a tick of the ten-second timer during a refresh starts no other refresh", async () => {
-    const { page, refreshBalances } = await boot();
-    const refresh = await holdRefresh(page);
-    const calls = refreshBalances.mock.calls.length;
-
-    await page.tick();
-
-    await refresh.finish();
-    await page.settle();
-
-    expect(refreshBalances).toHaveBeenCalledTimes(calls);
-});

tests/resolveTokenSymbol.test.js

@@ -67,15 +67,13 @@ beforeEach(() => {
 });
 
 describe("resolveTokenSymbol", () => {
-    // The bundled list is read only for a token on Ethereum Mainnet.
     test("reads the bundled list", () => {
-        expect(resolveTokenSymbol(USDC, { chainId: "0x1" })).toBe("USDC");
+        expect(resolveTokenSymbol(USDC, state)).toBe("USDC");
     });
 
     test("prefers the bundled list over a tracked entry", () => {
         state.trackedTokens = [{ address: USDC, symbol: "NOTUSDC" }];
-        const sources = { chainId: "0x1", trackedTokens: state.trackedTokens };
-        expect(resolveTokenSymbol(USDC, sources)).toBe("USDC");
+        expect(resolveTokenSymbol(USDC, state)).toBe("USDC");
     });
 
     test("reads a token the user tracks", () => {
@@ -106,19 +104,7 @@ describe("resolveTokenSymbol", () => {
     test("rejects a tracked entry claiming a bundled ticker it is not", () => {
         // NOVEL_TOKEN is not the real USDC contract, so it may not wear USDC.
         state.trackedTokens = [{ address: NOVEL_TOKEN, symbol: "USDC" }];
-        const sources = { chainId: "0x1", trackedTokens: state.trackedTokens };
-        expect(resolveTokenSymbol(NOVEL_TOKEN, sources)).toBeNull();
-    });
-
-    // The bundled list holds mainnet contracts, so on Sepolia any contract may
-    // carry one of its symbols.
-    test("on Sepolia, reads a tracked entry carrying a bundled ticker", () => {
-        state.trackedTokens = [{ address: NOVEL_TOKEN, symbol: "USDC" }];
-        const sources = {
-            chainId: "0xaa36a7",
-            trackedTokens: state.trackedTokens,
-        };
-        expect(resolveTokenSymbol(NOVEL_TOKEN, sources)).toBe("USDC");
+        expect(resolveTokenSymbol(NOVEL_TOKEN, state)).toBeNull();
     });
 
     test("rejects an explorer entry claiming the native ETH ticker", () => {

tests/sendAmountRule.test.js

@@ -131,14 +131,10 @@ async function review(amount, token) {
 async function confirm(amount, token) {
     const txInfo = await review("0.5", token);
     confirmTx.show({ ...txInfo, amount });
-    for (let i = 0; i < 10; i++) await jest.advanceTimersByTimeAsync(0);
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
 }
 
-// showFlash() starts a timer that clears the message two seconds later. Each
-// test here runs on fake timers and drops them in afterEach, so that timer
-// never outlives the test.
 beforeEach(() => {
-    jest.useFakeTimers();
     elements.clear();
     state.wallets = [
         {
@@ -171,10 +167,6 @@ beforeEach(() => {
     state.currentView = null;
 });
 
-afterEach(() => {
-    jest.useRealTimers();
-});
-
 describe.each([
     ["1e-3", "ETH"],
     ["1e-3", "TOK"],

tests/sendMax.test.js

@@ -277,18 +277,14 @@ async function review() {
 
 // show() starts the fee estimate without awaiting it; this lets it settle.
 async function settle() {
-    for (let i = 0; i < 10; i++) await jest.advanceTimersByTimeAsync(0);
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
 }
 
 function canSend() {
     return !el("btn-confirm-send").disabled;
 }
 
-// showFlash() starts a timer that clears the message two seconds later. Each
-// test here runs on fake timers and drops them in afterEach, so that timer
-// never outlives the test.
 beforeEach(() => {
-    jest.useFakeTimers();
     elements.clear();
     log.errorf.mockClear();
     pageClosed = new AbortController();
@@ -301,10 +297,6 @@ beforeEach(() => {
     mockNode.broadcast = [];
 });
 
-afterEach(() => {
-    jest.useRealTimers();
-});
-
 describe("Max on an ETH send", () => {
     test("fills in the exact balance minus the fee reserve", async () => {
         await refreshWith(BALANCE_WEI);

tests/settingsEndpointSave.test.js

@@ -1,438 +0,0 @@
-// Another page stores a different RPC or Blockscout URL for the same network.
-// Then the user taps "Save" in Settings on this page, on the URL that this page
-// loaded. The URL on screen is stored, and the flash message reads "Saved."
-// (https://git.eeqj.de/sneak/AutistMask/issues/688). Driven through the real
-// popup over a stored profile on Ethereum Mainnet.
-
-const {
-    bootPopup,
-    cleanupPopup,
-    unversionedValidProfile,
-} = require("./support/popupBoot");
-const { NETWORKS } = require("../src/shared/networks");
-
-afterEach(() => {
-    cleanupPopup();
-});
-
-test.each([
-    { button: "btn-save-rpc", input: "settings-rpc", field: "rpcUrl" },
-    {
-        button: "btn-save-blockscout",
-        input: "settings-blockscout",
-        field: "blockscoutUrl",
-    },
-])(
-    "$button stores the URL on screen after another page stored a different one",
-    async ({ button, input, field }) => {
-        const page = await bootPopup(unversionedValidProfile());
-        await page.click("btn-settings");
-        const url = page.value(input);
-        // This write sends this page no storage change event.
-        page.storage.write("autistmask", {
-            ...page.storage.read("autistmask"),
-            [field]: "https://other-page.example.invalid",
-        });
-        // This answer passes both endpoint checks on Ethereum Mainnet. The RPC
-        // check reads Ethereum Mainnet's chain id from it. The Blockscout check
-        // reads `ok`.
-        globalThis.fetch.mockResolvedValue({
-            ok: true,
-            json: async () => ({ result: NETWORKS.mainnet.chainId }),
-        });
-
-        await page.click(button);
-
-        expect(page.storage.read("autistmask")[field]).toBe(url);
-        expect(page.text("flash-msg")).toBe("Saved.");
-    },
-);
-
-// The user types a URL in Settings and taps "Save". While the check waits for
-// the endpoint's answer, another page turns "Use Blockscout" on. This page
-// follows that change and draws Settings again, with the stored URL in the
-// input. The check then passes. The typed URL is not stored. The flash message
-// says that the URL was changed during the check
-// (https://git.eeqj.de/sneak/AutistMask/issues/695).
-test.each([
-    { button: "btn-save-rpc", input: "settings-rpc", field: "rpcUrl" },
-    {
-        button: "btn-save-blockscout",
-        input: "settings-blockscout",
-        field: "blockscoutUrl",
-    },
-])(
-    "$button stores nothing when Settings is drawn again during the check",
-    async ({ button, input, field }) => {
-        const page = await bootPopup(unversionedValidProfile());
-        await page.click("btn-settings");
-        const storedUrl = page.value(input);
-        let answer;
-        globalThis.fetch.mockReturnValue(
-            new Promise((resolve) => {
-                answer = resolve;
-            }),
-        );
-
-        page.node(input).value = "https://typed.example.invalid";
-        const saving = page.node(button).listeners.click.map((fn) => fn());
-        await page.settle();
-        // The browser announces this write to this page.
-        await page.storage.local.set({
-            autistmask: {
-                ...page.storage.read("autistmask"),
-                useBlockscout: true,
-            },
-        });
-        await page.settle();
-        expect(page.node("settings-use-blockscout").checked).toBe(true);
-        // This answer passes both endpoint checks on Ethereum Mainnet.
-        answer({
-            ok: true,
-            json: async () => ({ result: NETWORKS.mainnet.chainId }),
-        });
-        await Promise.all(saving);
-        await page.settle();
-
-        expect(page.storage.read("autistmask")[field]).toBe(storedUrl);
-        expect(page.value(input)).toBe(storedUrl);
-        expect(page.text("flash-msg")).toBe(
-            "The URL was not saved because it was changed during the check.",
-        );
-    },
-);
-
-// As above, but another write holds the lock. So this page's follow of the
-// change to "Use Blockscout" waits for the lock. The endpoint answers while the
-// input still shows the typed URL. The save then asks for the lock, after the
-// follow did. So the follow draws Settings again before the save compares the
-// input.
-test.each([
-    { button: "btn-save-rpc", input: "settings-rpc", field: "rpcUrl" },
-    {
-        button: "btn-save-blockscout",
-        input: "settings-blockscout",
-        field: "blockscoutUrl",
-    },
-])(
-    "$button stores nothing when Settings is drawn again while the save waits for the lock",
-    async ({ button, input, field }) => {
-        const page = await bootPopup(unversionedValidProfile());
-        await page.click("btn-settings");
-        const storedUrl = page.value(input);
-        let answer;
-        globalThis.fetch.mockReturnValue(
-            new Promise((resolve) => {
-                answer = resolve;
-            }),
-        );
-        const typedUrl = "https://typed.example.invalid";
-
-        page.node(input).value = typedUrl;
-        const saving = page.node(button).listeners.click.map((fn) => fn());
-        await page.settle();
-        let releaseLock;
-        const lockHeld = navigator.locks.request(
-            "autistmask",
-            () =>
-                new Promise((resolve) => {
-                    releaseLock = resolve;
-                }),
-        );
-        // The browser announces this write to this page.
-        await page.storage.local.set({
-            autistmask: {
-                ...page.storage.read("autistmask"),
-                useBlockscout: true,
-            },
-        });
-        await page.settle();
-        // This answer passes both endpoint checks on Ethereum Mainnet.
-        answer({
-            ok: true,
-            json: async () => ({ result: NETWORKS.mainnet.chainId }),
-        });
-        await page.settle();
-        expect(page.value(input)).toBe(typedUrl);
-        releaseLock();
-        await lockHeld;
-        await Promise.all(saving);
-        await page.settle();
-
-        expect(page.node("settings-use-blockscout").checked).toBe(true);
-        expect(page.storage.read("autistmask")[field]).toBe(storedUrl);
-        expect(page.value(input)).toBe(storedUrl);
-        expect(page.text("flash-msg")).toBe(
-            "The URL was not saved because it was changed during the check.",
-        );
-    },
-);
-
-// This answer passes both endpoint checks on Ethereum Mainnet.
-const PASSING_ANSWER = {
-    ok: true,
-    json: async () => ({ result: NETWORKS.mainnet.chainId }),
-};
-
-// Both endpoint checks read this answer as an error. The RPC check reads the
-// answer's `error`. The Blockscout check reads the answer's `ok`.
-const ERROR_ANSWER = {
-    ok: false,
-    status: 500,
-    json: async () => ({ error: { code: -32603, message: "Internal error" } }),
-};
-
-// The user types a URL in Settings and taps "Save". Before the endpoint answers,
-// the user types a second URL and taps "Save" again. The second check passes
-// first. The second URL is stored, and the flash message reads "Saved.". The
-// first check then ends in one of three ways:
-//
-// - It passes.
-// - It fails, because fetch cannot reach the endpoint.
-// - It gets an answer that holds an error.
-//
-// None of the three changes the stored URL or the flash message
-// (https://git.eeqj.de/sneak/AutistMask/issues/698).
-test.each([
-    {
-        button: "btn-save-rpc",
-        input: "settings-rpc",
-        field: "rpcUrl",
-        first: "passes",
-    },
-    {
-        button: "btn-save-rpc",
-        input: "settings-rpc",
-        field: "rpcUrl",
-        first: "fails",
-    },
-    {
-        button: "btn-save-rpc",
-        input: "settings-rpc",
-        field: "rpcUrl",
-        first: "answers with an error",
-    },
-    {
-        button: "btn-save-blockscout",
-        input: "settings-blockscout",
-        field: "blockscoutUrl",
-        first: "passes",
-    },
-    {
-        button: "btn-save-blockscout",
-        input: "settings-blockscout",
-        field: "blockscoutUrl",
-        first: "fails",
-    },
-    {
-        button: "btn-save-blockscout",
-        input: "settings-blockscout",
-        field: "blockscoutUrl",
-        first: "answers with an error",
-    },
-])(
-    "$button keeps the second tap's result when the first check $first last",
-    async ({ button, input, field, first }) => {
-        const page = await bootPopup(unversionedValidProfile());
-        await page.click("btn-settings");
-        const checks = [];
-        globalThis.fetch.mockImplementation(
-            () =>
-                new Promise((resolve, reject) => {
-                    checks.push({ resolve, reject });
-                }),
-        );
-        const secondUrl = "https://second.example.invalid";
-
-        page.node(input).value = "https://first.example.invalid";
-        const firstTap = page.node(button).listeners.click.map((fn) => fn());
-        await page.settle();
-        page.node(input).value = secondUrl;
-        const secondTap = page.node(button).listeners.click.map((fn) => fn());
-        await page.settle();
-        checks[1].resolve(PASSING_ANSWER);
-        await Promise.all(secondTap);
-        await page.settle();
-        expect(page.text("flash-msg")).toBe("Saved.");
-        if (first === "passes") {
-            checks[0].resolve(PASSING_ANSWER);
-        } else if (first === "answers with an error") {
-            checks[0].resolve(ERROR_ANSWER);
-        } else {
-            // fetch rejects when it cannot reach the endpoint.
-            checks[0].reject(new TypeError("Failed to fetch"));
-        }
-        await Promise.all(firstTap);
-        await page.settle();
-
-        expect(checks).toHaveLength(2);
-        expect(page.storage.read("autistmask")[field]).toBe(secondUrl);
-        expect(page.text("flash-msg")).toBe("Saved.");
-    },
-);
-
-// The user types a URL in Settings and taps "Save". Before the endpoint answers,
-// the user empties the input and taps "Save" again. The flash message asks for
-// a URL. The first check then passes. The flash message still asks for a URL,
-// and the stored URL is unchanged.
-test.each([
-    {
-        button: "btn-save-rpc",
-        input: "settings-rpc",
-        field: "rpcUrl",
-        message: "Please enter an RPC URL.",
-    },
-    {
-        button: "btn-save-blockscout",
-        input: "settings-blockscout",
-        field: "blockscoutUrl",
-        message: "Please enter a Blockscout API URL.",
-    },
-])(
-    "$button keeps the empty-input message when the first check passes last",
-    async ({ button, input, field, message }) => {
-        const page = await bootPopup(unversionedValidProfile());
-        await page.click("btn-settings");
-        const storedUrl = page.value(input);
-        let answer;
-        globalThis.fetch.mockReturnValue(
-            new Promise((resolve) => {
-                answer = resolve;
-            }),
-        );
-
-        page.node(input).value = "https://typed.example.invalid";
-        const firstTap = page.node(button).listeners.click.map((fn) => fn());
-        await page.settle();
-        page.node(input).value = "";
-        await page.click(button);
-        expect(page.text("flash-msg")).toBe(message);
-        answer(PASSING_ANSWER);
-        await Promise.all(firstTap);
-        await page.settle();
-
-        expect(page.storage.read("autistmask")[field]).toBe(storedUrl);
-        expect(page.text("flash-msg")).toBe(message);
-    },
-);
-
-// The user types a URL in Settings and taps "Save". Another write holds the
-// lock. So the save waits for the lock once the check passes. The user then
-// taps "Save" again on the same URL. When the lock is free, the first save
-// stores nothing and shows no flash message. The second check then passes, and
-// the second save stores the URL.
-test.each([
-    { button: "btn-save-rpc", input: "settings-rpc", field: "rpcUrl" },
-    {
-        button: "btn-save-blockscout",
-        input: "settings-blockscout",
-        field: "blockscoutUrl",
-    },
-])(
-    "$button stores nothing for an earlier tap still waiting for the lock",
-    async ({ button, input, field }) => {
-        const page = await bootPopup(unversionedValidProfile());
-        await page.click("btn-settings");
-        const storedUrl = page.value(input);
-        const checks = [];
-        globalThis.fetch.mockImplementation(
-            () =>
-                new Promise((resolve) => {
-                    checks.push(resolve);
-                }),
-        );
-        const typedUrl = "https://typed.example.invalid";
-
-        page.node(input).value = typedUrl;
-        const firstTap = page.node(button).listeners.click.map((fn) => fn());
-        await page.settle();
-        let releaseLock;
-        const lockHeld = navigator.locks.request(
-            "autistmask",
-            () =>
-                new Promise((resolve) => {
-                    releaseLock = resolve;
-                }),
-        );
-        checks[0](PASSING_ANSWER);
-        await page.settle();
-        const secondTap = page.node(button).listeners.click.map((fn) => fn());
-        await page.settle();
-        releaseLock();
-        await lockHeld;
-        await Promise.all(firstTap);
-        await page.settle();
-
-        expect(page.storage.read("autistmask")[field]).toBe(storedUrl);
-        expect(page.text("flash-msg")).toBe("Testing endpoint...");
-
-        checks[1](PASSING_ANSWER);
-        await Promise.all(secondTap);
-        await page.settle();
-
-        expect(checks).toHaveLength(2);
-        expect(page.storage.read("autistmask")[field]).toBe(typedUrl);
-        expect(page.text("flash-msg")).toBe("Saved.");
-    },
-);
-
-// The user taps "Save", and the check passes. The save then begins its storage
-// write, and this test keeps the write waiting. The user taps "Save" again, and
-// the second check cannot reach the endpoint. When the write ends, the flash
-// message still reads "Could not reach endpoint.". The write stores the URL
-// anyway, because the write began before the second tap.
-test.each([
-    { button: "btn-save-rpc", input: "settings-rpc", field: "rpcUrl" },
-    {
-        button: "btn-save-blockscout",
-        input: "settings-blockscout",
-        field: "blockscoutUrl",
-    },
-])(
-    "$button keeps the second tap's message when tapped again during the write",
-    async ({ button, input, field }) => {
-        const page = await bootPopup(unversionedValidProfile());
-        await page.click("btn-settings");
-        const checks = [];
-        globalThis.fetch.mockImplementation(
-            () =>
-                new Promise((resolve, reject) => {
-                    checks.push({ resolve, reject });
-                }),
-        );
-        const typedUrl = "https://typed.example.invalid";
-
-        page.node(input).value = typedUrl;
-        const firstTap = page.node(button).listeners.click.map((fn) => fn());
-        await page.settle();
-        const { set } = page.storage.local;
-        const write = set.getMockImplementation();
-        let writeBegan = false;
-        let releaseWrite;
-        const writeHeld = new Promise((resolve) => {
-            releaseWrite = resolve;
-        });
-        set.mockImplementationOnce(async (items) => {
-            writeBegan = true;
-            await writeHeld;
-            await write(items);
-        });
-        checks[0].resolve(PASSING_ANSWER);
-        await page.settle();
-        expect(writeBegan).toBe(true);
-        const secondTap = page.node(button).listeners.click.map((fn) => fn());
-        await page.settle();
-        // fetch rejects when it cannot reach the endpoint.
-        checks[1].reject(new TypeError("Failed to fetch"));
-        await Promise.all(secondTap);
-        await page.settle();
-        expect(page.text("flash-msg")).toBe("Could not reach endpoint.");
-        releaseWrite();
-        await Promise.all(firstTap);
-        await page.settle();
-
-        expect(checks).toHaveLength(2);
-        expect(page.storage.read("autistmask")[field]).toBe(typedUrl);
-        expect(page.text("flash-msg")).toBe("Could not reach endpoint.");
-    },
-);

tests/spoofedTrackedToken.test.js

@@ -1,134 +0,0 @@
-// A token that the spoof rule refuses never shows in the balance list, even
-// tracked at zero balance with "Show tracked tokens with zero balance" on, and
-// the two add-token screens refuse to track one
-// (https://git.eeqj.de/sneak/AutistMask/issues/705). Driven through the real
-// popup over a stored profile.
-
-const {
-    bootPopup,
-    cleanupPopup,
-    unversionedValidProfile,
-    TOKEN_ADDRESS,
-} = require("./support/popupBoot");
-
-// Claims the symbol of the bundled USDT from another contract.
-const FAKE_USDT = {
-    address: TOKEN_ADDRESS,
-    symbol: "USDT",
-    decimals: 6,
-    name: "Tether USD",
-};
-// A Sepolia contract that reports USDT. The bundled list holds Ethereum Mainnet
-// contracts, so the spoof rule does not check this symbol on Sepolia
-// (https://git.eeqj.de/sneak/AutistMask/issues/632).
-const SEPOLIA_USDT = {
-    address: TOKEN_ADDRESS,
-    symbol: "USDT",
-    decimals: 6,
-    name: "Test USDT",
-};
-// A symbol the bundled list does not have, so the spoof rule passes it.
-const TEST_TOKEN = {
-    address: "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
-    symbol: "TST",
-    decimals: 18,
-    name: "Test Token",
-};
-const REFUSED_FLASH = "Not added: this token fakes a known symbol.";
-
-afterEach(() => {
-    cleanupPopup();
-});
-
-test("on Ethereum Mainnet, a fake token tracked at zero balance is not listed while zero balances are shown", async () => {
-    const boot = await bootPopup(
-        unversionedValidProfile({
-            networkId: "mainnet",
-            currentView: "address",
-            selectedWallet: 0,
-            selectedAddress: 0,
-            trackedTokens: [FAKE_USDT, TEST_TOKEN],
-            showZeroBalanceTokens: true,
-        }),
-    );
-    const rows = boot.node("address-balances").innerHTML;
-    expect(rows).toContain(`data-token="${TEST_TOKEN.address.toLowerCase()}"`);
-    expect(rows).not.toContain(
-        `data-token="${FAKE_USDT.address.toLowerCase()}"`,
-    );
-});
-
-// Each screen is opened from AddressDetail by the buttons named, in order.
-describe.each([
-    [
-        "AddToken",
-        ["btn-add-token"],
-        "add-token",
-        "add-token-address",
-        "btn-add-token-confirm",
-    ],
-    [
-        "SettingsAddToken",
-        ["btn-settings", "btn-settings-add-token"],
-        "settings-addtoken",
-        "settings-addtoken-address",
-        "btn-settings-addtoken-manual",
-    ],
-])("%s", (_, opening, view, field, button) => {
-    test("on Ethereum Mainnet, refuses a fake token by contract address", async () => {
-        const boot = await bootPopup(
-            unversionedValidProfile({
-                networkId: "mainnet",
-                currentView: "address",
-                selectedWallet: 0,
-                selectedAddress: 0,
-            }),
-        );
-        for (const id of opening) await boot.click(id);
-        expect(boot.visibleViews()).toEqual([view]);
-        const { lookupTokenInfo } = require("../src/shared/balances");
-        lookupTokenInfo.mockResolvedValueOnce({
-            symbol: FAKE_USDT.symbol,
-            decimals: FAKE_USDT.decimals,
-            name: FAKE_USDT.name,
-        });
-        boot.node(field).value = FAKE_USDT.address;
-
-        await boot.click(button);
-        expect(boot.text("flash-msg")).toBe(REFUSED_FLASH);
-        expect(boot.visibleViews()).toEqual([view]);
-        expect(boot.storage.read("autistmask").trackedTokens).toEqual([]);
-    });
-
-    test("on Sepolia, adds a contract that reports USDT and lists it", async () => {
-        const boot = await bootPopup(
-            unversionedValidProfile({
-                networkId: "sepolia",
-                currentView: "address",
-                selectedWallet: 0,
-                selectedAddress: 0,
-                showZeroBalanceTokens: true,
-            }),
-        );
-        for (const id of opening) await boot.click(id);
-        expect(boot.visibleViews()).toEqual([view]);
-        const { lookupTokenInfo } = require("../src/shared/balances");
-        lookupTokenInfo.mockResolvedValueOnce({
-            symbol: SEPOLIA_USDT.symbol,
-            decimals: SEPOLIA_USDT.decimals,
-            name: SEPOLIA_USDT.name,
-        });
-        boot.node(field).value = SEPOLIA_USDT.address;
-
-        await boot.click(button);
-        expect(boot.text("flash-msg")).not.toBe(REFUSED_FLASH);
-        expect(boot.storage.read("autistmask").trackedTokens).toEqual([
-            expect.objectContaining(SEPOLIA_USDT),
-        ]);
-        // SettingsAddToken stays up after adding, so this draws AddressDetail.
-        require("../src/popup/views/addressDetail").show();
-        expect(boot.node("address-balances").innerHTML).toContain(
-            `data-token="${SEPOLIA_USDT.address.toLowerCase()}"`,
-        );
-    });
-});

tests/stateRecovery.test.js

@@ -23,9 +23,6 @@
 // version field, and showing those users a wipe prompt would be a worse defect
 // than the one being fixed. It is migrated in place and keeps working.
 
-const fs = require("fs");
-const path = require("path");
-
 const {
     bootPopup,
     cleanupPopup,
@@ -151,29 +148,6 @@ describe("the destructive reset on the recovery screen", () => {
     });
 });
 
-// A key or xprv wallet has no recovery phrase, so the erase warning names all
-// three backups (https://git.eeqj.de/sneak/AutistMask/issues/593). The boot
-// harness holds no static text, so this reads the markup itself.
-describe("the erase warning on the recovery screen", () => {
-    test("names the recovery phrase, the private key and the extended private key", () => {
-        const html = fs.readFileSync(
-            path.join(__dirname, "..", "src", "popup", "index.html"),
-            "utf8",
-        );
-        const start = html.indexOf('id="view-state-recovery"');
-        const end = html.indexOf('id="btn-state-recovery-reset"', start);
-        const screenText = html
-            .slice(start, end)
-            .replace(/<[^>]*>/g, " ")
-            .replace(/\s+/g, " ");
-
-        expect(screenText).toContain(
-            "If you kept a copy of a wallet's recovery phrase, private key or " +
-                "extended private key, you can add that wallet again.",
-        );
-    });
-});
-
 describe("a popup already open when the stored profile becomes unreadable", () => {
     // https://git.eeqj.de/sneak/AutistMask/issues/373. The popup used to stay
     // on the wallet list with the last good balances, and only a reopen

tests/support/popupBoot.js

@@ -279,11 +279,10 @@ async function bootPopup(stored, options) {
         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. refreshBalances()
-    // answers as a refresh that read no tracked token's balance.
+    // no used address: AddWallet reads `addresses` from it.
     jest.doMock("../../src/shared/balances", () => ({
         fetchTokenBalances: jest.fn(async () => []),
-        refreshBalances: jest.fn(async () => []),
+        refreshBalances: jest.fn(async () => {}),
         dropUntrackedTokens: jest.requireActual("../../src/shared/balances")
             .dropUntrackedTokens,
         lookupTokenInfo: jest.fn(async () => null),

tests/swapStatusAmount.test.js

@@ -340,75 +340,3 @@ describe.each([
         expect(node("error-tx-summary").textContent).toBe("1.0000 ETH");
     });
 });
-
-// https://git.eeqj.de/sneak/AutistMask/issues/722: a WRAP_ETH of 1 ETH into the
-// router, an UNWRAP_WETH into the router, then a V4 swap of 1 ETH the user
-// settles. The Amount line reads 1.0000 ETH, though up to 2 ETH can leave. The
-// rest is on the swap's own Moved from the sender line.
-describe("a swap with a Moved from the sender line of its own", () => {
-    const ADDRESS_THIS = "0x0000000000000000000000000000000000000002";
-    const TWO_ETH = 2n * ONE_ETH;
-    const SEND_FAILS = {
-        error: "The transaction could not be sent.",
-        retryable: false,
-    };
-    const data = routerIface.encodeFunctionData("execute", [
-        "0x0b0c10",
-        [
-            // WRAP_ETH and UNWRAP_WETH have the same layout.
-            coder.encode(["address", "uint256"], [ADDRESS_THIS, ONE_ETH]),
-            coder.encode(["address", "uint256"], [ADDRESS_THIS, 0n]),
-            coder.encode(
-                ["bytes", "bytes[]"],
-                [
-                    new Uint8Array([SWAP_EXACT_IN_SINGLE, SETTLE, TAKE_ALL]),
-                    [
-                        coder.encode(
-                            [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
-                            [[ETH_USDC_POOL, true, ONE_ETH, 990000n, "0x"]],
-                        ),
-                        // The user pays this one, not the router.
-                        coder.encode(
-                            ["address", "uint256", "bool"],
-                            [ZERO, 0n, true],
-                        ),
-                        takeAllUsdc,
-                    ],
-                ],
-            ),
-        ],
-        9999999999n,
-    ]);
-
-    function expectMovedLine(id) {
-        const html = node(id).innerHTML;
-        expect(html).toContain("Moved from the sender");
-        expect(html).toContain("Up to 1.0000 ETH");
-    }
-
-    test("the wait screen shows that line's amount under the Amount figure", async () => {
-        await approveSwap(data, { txHash: TX_HASH }, TWO_ETH);
-        expect(node("wait-tx-summary").textContent).toBe("1.0000 ETH");
-        expectMovedLine("wait-tx-token-note");
-    });
-
-    test("the error screen shows that line's amount under the Amount figure", async () => {
-        await approveSwap(data, SEND_FAILS, TWO_ETH);
-        expect(node("error-tx-summary").textContent).toBe("1.0000 ETH");
-        expectMovedLine("error-tx-token-note");
-    });
-
-    test("a reopened popup's wait screen still shows it", async () => {
-        await approveSwap(data, { txHash: TX_HASH }, TWO_ETH);
-        node("wait-tx-token-note").innerHTML = "";
-        txStatus.restoreWait();
-        expectMovedLine("wait-tx-token-note");
-    });
-
-    test("a reopened popup's error screen still shows it", async () => {
-        await approveSwap(data, SEND_FAILS, TWO_ETH);
-        node("error-tx-token-note").innerHTML = "";
-        txStatus.renderError();
-        expectMovedLine("error-tx-token-note");
-    });
-});

tests/symbolSpoof.test.js

@@ -72,11 +72,6 @@ const {
 const { renderSendTokenSelect } = require("../src/popup/views/send");
 const { state } = require("../src/shared/state");
 const { debugFetch } = require("../src/shared/log");
-const { NETWORKS } = require("../src/shared/networks");
-
-// The bundled list's symbols are known symbols only on Ethereum Mainnet.
-const MAINNET = NETWORKS.mainnet.chainId;
-const SEPOLIA = NETWORKS.sepolia.chainId;
 
 // The fake "Ethereum" token with symbol "ETH" from the attack documented in
 // README.md, given a holder count high enough to clear every other filter so
@@ -121,29 +116,14 @@ describe("the shared rule", () => {
     });
 
     test("a known symbol from its own contract is not a spoof", () => {
-        expect(isSpoofedSymbol("USDC", USDC_CONTRACT, MAINNET)).toBe(false);
-        expect(
-            isSpoofedSymbol("usdc", USDC_CONTRACT.toUpperCase(), MAINNET),
-        ).toBe(false);
+        expect(isSpoofedSymbol("USDC", USDC_CONTRACT)).toBe(false);
+        expect(isSpoofedSymbol("usdc", USDC_CONTRACT.toUpperCase())).toBe(
+            false,
+        );
     });
 
     test("a known symbol from another contract is a spoof", () => {
-        expect(isSpoofedSymbol("USDC", FAKE_ETH_CONTRACT, MAINNET)).toBe(true);
-    });
-
-    // https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled list holds
-    // mainnet contracts, so on Sepolia any contract may carry one of its
-    // symbols.
-    test("on Sepolia, a bundled symbol from any contract is not a spoof", () => {
-        expect(isSpoofedSymbol("USDC", FAKE_ETH_CONTRACT, SEPOLIA)).toBe(false);
-        expect(isSpoofedSymbol("USDC", USDC_CONTRACT, SEPOLIA)).toBe(false);
-    });
-
-    test("on Sepolia, the native asset's labels are still reserved", () => {
-        expect(isSpoofedSymbol("ETH", FAKE_ETH_CONTRACT, SEPOLIA)).toBe(true);
-        expect(isSpoofedSymbol("SepoliaETH", FAKE_ETH_CONTRACT, SEPOLIA)).toBe(
-            true,
-        );
+        expect(isSpoofedSymbol("USDC", FAKE_ETH_CONTRACT)).toBe(true);
     });
 
     test("a symbol that is not in the table is not judged here", () => {
@@ -184,9 +164,7 @@ describe("the shared rule: symbols that render as a known symbol", () => {
     test("ASCII padding does not buy a pass", () => {
         expect(isSpoofedSymbol(" ETH ", FAKE_ETH_CONTRACT)).toBe(true);
         expect(isSpoofedSymbol("\tETH\n", FAKE_ETH_CONTRACT)).toBe(true);
-        expect(isSpoofedSymbol("  usdc  ", FAKE_ETH_CONTRACT, MAINNET)).toBe(
-            true,
-        );
+        expect(isSpoofedSymbol("  usdc  ", FAKE_ETH_CONTRACT)).toBe(true);
     });
 
     test("non-breaking and other Unicode spaces do not either", () => {
@@ -265,9 +243,7 @@ describe("the shared rule: symbols that render as a known symbol", () => {
 
     test("compatibility forms fold onto the symbol they imitate", () => {
         expect(isSpoofedSymbol(FULLWIDTH_ETH, FAKE_ETH_CONTRACT)).toBe(true);
-        expect(
-            isSpoofedSymbol(FULLWIDTH_USDC, FAKE_ETH_CONTRACT, MAINNET),
-        ).toBe(true);
+        expect(isSpoofedSymbol(FULLWIDTH_USDC, FAKE_ETH_CONTRACT)).toBe(true);
     });
 
     // The two knowingly open classes, asserted here so that the boundary is
@@ -295,10 +271,8 @@ describe("the shared rule: symbols that render as a known symbol", () => {
     });
 
     test("a genuine contract still bears its own padded symbol", () => {
-        expect(isSpoofedSymbol(" USDC ", USDC_CONTRACT, MAINNET)).toBe(false);
-        expect(isSpoofedSymbol(ZWSP + "WETH", WETH_CONTRACT, MAINNET)).toBe(
-            false,
-        );
+        expect(isSpoofedSymbol(" USDC ", USDC_CONTRACT)).toBe(false);
+        expect(isSpoofedSymbol(ZWSP + "WETH", WETH_CONTRACT)).toBe(false);
     });
 
     // Normalization must not invent a match.  Interior ASCII whitespace is
@@ -322,7 +296,7 @@ describe("the shared rule: symbols that render as a known symbol", () => {
             expect(symbol).toMatch(/^[!-~]+$/);
             if (addresses === null) continue;
             for (const address of addresses) {
-                expect(isSpoofedSymbol(symbol, address, MAINNET)).toBe(false);
+                expect(isSpoofedSymbol(symbol, address)).toBe(false);
             }
         }
     });
@@ -343,7 +317,7 @@ describe("the shared rule: symbols that render as a known symbol", () => {
 describe("the shipped token list", () => {
     test("no bundled token is filtered at its own address", () => {
         const filtered = TOKENS.filter((t) =>
-            isSpoofedSymbol(t.symbol, t.address, MAINNET),
+            isSpoofedSymbol(t.symbol, t.address),
         ).map((t) => t.symbol + " @ " + t.address);
         expect(filtered).toEqual([]);
     });
@@ -386,9 +360,7 @@ describe("the shipped token list", () => {
         expect(shared.length).toBeGreaterThan(0);
         for (const [, list] of shared) {
             for (const t of list) {
-                expect(isSpoofedSymbol(t.symbol, t.address, MAINNET)).toBe(
-                    false,
-                );
+                expect(isSpoofedSymbol(t.symbol, t.address)).toBe(false);
             }
         }
     });
@@ -432,7 +404,7 @@ describe("the shipped token list", () => {
                 [...addresses].sort(),
             );
             for (const address of addresses) {
-                expect(isSpoofedSymbol(symbol, address, MAINNET)).toBe(false);
+                expect(isSpoofedSymbol(symbol, address)).toBe(false);
             }
         }
     });
@@ -449,9 +421,7 @@ describe("the shipped token list", () => {
         }
         for (const [symbol, list] of bySymbol) {
             if (list.length < 2) continue;
-            expect(isSpoofedSymbol(symbol, FAKE_ETH_CONTRACT, MAINNET)).toBe(
-                true,
-            );
+            expect(isSpoofedSymbol(symbol, FAKE_ETH_CONTRACT)).toBe(true);
         }
     });
 });
@@ -536,40 +506,10 @@ describe("surface 2: the Send token selector", () => {
     }
 
     beforeEach(() => {
-        state.networkId = "mainnet";
         state.fraudContracts = [];
         state.hideLowHolderTokens = true;
     });
 
-    afterAll(() => {
-        state.networkId = "mainnet";
-    });
-
-    // A token reporting USDC's symbol from another contract.
-    function otherUsdc() {
-        return {
-            address: FAKE_ETH_CONTRACT,
-            symbol: "USDC",
-            decimals: 6,
-            balance: "12.5",
-            holders: 900000,
-        };
-    }
-
-    test("a bundled symbol from another contract is not selectable", () => {
-        render([otherUsdc()]);
-        expect(select.children).toEqual([]);
-    });
-
-    // https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled list holds
-    // mainnet contracts, so on Sepolia any contract may carry its symbols.
-    test("with Sepolia active, a bundled symbol from another contract is selectable", () => {
-        state.networkId = "sepolia";
-        render([otherUsdc()]);
-        expect(select.children).toHaveLength(1);
-        expect(select.children[0].value).toBe(FAKE_ETH_CONTRACT);
-    });
-
     test("a fake ETH token is not selectable", () => {
         render([
             {
@@ -687,12 +627,7 @@ describe("surface 3: the balance list", () => {
                 decimals: "6",
             }),
         ]);
-        const balances = await fetchTokenBalances(
-            HOLDER,
-            BLOCKSCOUT,
-            [],
-            MAINNET,
-        );
+        const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, []);
         expect(balances).toHaveLength(1);
         expect(balances[0].symbol).toBe(" USDC ");
     });
@@ -706,40 +641,11 @@ describe("surface 3: the balance list", () => {
                 decimals: "6",
             }),
         ]);
-        const balances = await fetchTokenBalances(
-            HOLDER,
-            BLOCKSCOUT,
-            [],
-            MAINNET,
-        );
+        const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, []);
         expect(balances).toHaveLength(1);
         expect(balances[0].symbol).toBe("USDC");
     });
 
-    // https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled list holds
-    // mainnet contracts, so on Sepolia any contract may carry its symbols.
-    test("a bundled symbol from another contract is listed on Sepolia only", async () => {
-        respondWith([fakeEthItem({ symbol: "USDC", decimals: "6" })]);
-        expect(
-            await fetchTokenBalances(HOLDER, BLOCKSCOUT, [], MAINNET),
-        ).toEqual([]);
-        const sepolia = await fetchTokenBalances(
-            HOLDER,
-            BLOCKSCOUT,
-            [],
-            SEPOLIA,
-        );
-        expect(sepolia).toHaveLength(1);
-        expect(sepolia[0].symbol).toBe("USDC");
-    });
-
-    test("a fake ETH token is filtered on Sepolia too", async () => {
-        respondWith([fakeEthItem()]);
-        expect(
-            await fetchTokenBalances(HOLDER, BLOCKSCOUT, [], SEPOLIA),
-        ).toEqual([]);
-    });
-
     // The trap in this change: the user's real ETH balance is not an ERC-20
     // and is fetched over RPC in refreshBalances, so it never passes through
     // this loop at all.  An explorer row that is not an ERC-20 is dropped

tests/trackedTokenBalances.test.js

@@ -133,13 +133,13 @@ function trackedRow(balance, decimals = null, holders = null) {
     };
 }
 
-async function refresh(addresses, trackedTokens, networkId = "mainnet") {
+async function refresh(addresses, trackedTokens) {
     await refreshBalances(
         [{ addresses }],
         RPC_URL,
         EXPLORER_URL,
         trackedTokens,
-        networkId,
+        "mainnet",
         new AbortController().signal,
     );
     return addresses;
@@ -307,104 +307,3 @@ test("a tracked token wearing a known symbol from another contract is not listed
     );
     expect(first.tokenBalances).toEqual([]);
 });
-
-test("the refresh resolves with each tracked token whose balance it read at every address", async () => {
-    const flaky = "0x9999999999999999999999999999999999999999";
-    holdings[TOKEN] = { [FIRST]: 2000000n, [SECOND]: 0n };
-    // balanceOf answers at FIRST and fails at SECOND.
-    holdings[flaky] = { [FIRST]: 2000000n };
-    const read = await refreshBalances(
-        [
-            {
-                addresses: [
-                    { address: FIRST, tokenBalances: [] },
-                    { address: SECOND, tokenBalances: [] },
-                ],
-            },
-        ],
-        RPC_URL,
-        EXPLORER_URL,
-        [
-            TRACKED,
-            { address: flaky, symbol: "FLK", name: "Flaky", decimals: 6 },
-            // A known symbol from another contract: its balance is not read.
-            { address: OTHER, symbol: "USDC", name: "Fake", decimals: 6 },
-        ],
-        "mainnet",
-        new AbortController().signal,
-    );
-    expect(read).toEqual([TOKEN]);
-});
-
-// https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled list holds
-// Ethereum Mainnet contracts. A token outside the tracked tokens with an
-// unknown holder count is listed only when the bundled list names it.
-test("an untracked bundled token with an unknown holder count is listed on Ethereum Mainnet only", async () => {
-    explorerRows = [explorerRow(USDC, "USDC", 5000000, null)];
-    const [mainnet] = await refresh(
-        [{ address: FIRST, tokenBalances: [] }],
-        [],
-    );
-    expect(mainnet.tokenBalances).toEqual([
-        {
-            address: USDC,
-            name: "USDC",
-            symbol: "USDC",
-            decimals: 6,
-            balance: "5.0",
-            holders: null,
-        },
-    ]);
-    const [sepolia] = await refresh(
-        [{ address: FIRST, tokenBalances: [] }],
-        [],
-        "sepolia",
-    );
-    expect(sepolia.tokenBalances).toEqual([]);
-});
-
-test("a tracked token at a bundled token's address takes the bundled scale on Ethereum Mainnet only", async () => {
-    holdings[USDC] = { [FIRST]: 5000000n };
-    // The tracked entry records no decimals, and Blockscout fails.
-    const tracked = [
-        { address: USDC, symbol: "USDC", name: "USD Coin", decimals: null },
-    ];
-    const row = (balance) => ({
-        address: USDC,
-        name: "USD Coin",
-        symbol: "USDC",
-        decimals: null,
-        balance: balance,
-        holders: null,
-    });
-    const [mainnet] = await refresh(
-        [{ address: FIRST, tokenBalances: [] }],
-        tracked,
-    );
-    expect(mainnet.tokenBalances).toEqual([row("5.0")]);
-    const [sepolia] = await refresh(
-        [{ address: FIRST, tokenBalances: [] }],
-        tracked,
-        "sepolia",
-    );
-    expect(sepolia.tokenBalances).toEqual([row(null)]);
-});
-
-test("with Sepolia active, a tracked token wearing a bundled symbol from another contract is listed", async () => {
-    holdings[OTHER] = { [FIRST]: 5000000n };
-    const [first] = await refresh(
-        [{ address: FIRST, tokenBalances: [] }],
-        [{ address: OTHER, symbol: "USDC", name: "Other", decimals: 6 }],
-        "sepolia",
-    );
-    expect(first.tokenBalances).toEqual([
-        {
-            address: OTHER,
-            name: "Other",
-            symbol: "USDC",
-            decimals: null,
-            balance: "5.0",
-            holders: null,
-        },
-    ]);
-});

tests/trackedTokensPerNetwork.test.js

@@ -5,9 +5,6 @@
 // a contract lookup that answers after one. Driven through the real popup over
 // a stored profile; the same switch made by the background is in
 // tests/coldWorkerChainSwitch.test.js.
-//
-// The tests of what another page stored before a switch in Settings cover a
-// fraud contract too (https://git.eeqj.de/sneak/AutistMask/issues/692).
 
 const {
     bootPopup,
@@ -117,17 +114,6 @@ async function chooseNetwork(boot, networkId) {
     await boot.settle();
 }
 
-// Adds NEW_TOKEN_ADDRESS by contract address on SettingsAddToken, as the user
-// does. Returns the record the add tracks.
-async function addNewToken(boot) {
-    const { lookupTokenInfo } = require("../src/shared/balances");
-    const info = { symbol: "NEW", decimals: 18, name: "New Token" };
-    lookupTokenInfo.mockResolvedValueOnce(info);
-    boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
-    await boot.click("btn-settings-addtoken-manual");
-    return { address: NEW_TOKEN_ADDRESS, ...info, balanceNotFetched: true };
-}
-
 // The Settings gear, a switch to Sepolia, and Back.
 async function gearSwitchBack(boot) {
     await boot.click("btn-settings");
@@ -173,9 +159,7 @@ test("a token added by contract address on Sepolia is tracked on Sepolia only",
         "sepolia",
         expect.anything(),
     );
-    // No refresh has read the new token's balance yet.
-    const added = { ...SEPOLIA_TOKEN, balanceNotFetched: true };
-    expect(stored().trackedTokens).toEqual([added]);
+    expect(stored().trackedTokens).toEqual([SEPOLIA_TOKEN]);
 
     await boot.click("btn-settings");
     await chooseNetwork(boot, "mainnet");
@@ -187,672 +171,12 @@ test("a token added by contract address on Sepolia is tracked on Sepolia only",
 
     await chooseNetwork(boot, "sepolia");
     expect(stored().networkId).toBe("sepolia");
-    expect(stored().trackedTokens).toEqual([added]);
+    expect(stored().trackedTokens).toEqual([SEPOLIA_TOKEN]);
     const onSepolia = boot.node("settings-tracked-tokens").innerHTML;
     expect(onSepolia).toContain("TST");
     expect(onSepolia).not.toContain("DAI");
 });
 
-// Another popup page tracks DAI on Ethereum Mainnet after this page's last
-// save. The switch to Sepolia puts DAI away under Ethereum Mainnet.
-test("a token another page tracked before a switch in Settings stays tracked on Ethereum Mainnet", async () => {
-    const boot = await bootPopup(unversionedValidProfile());
-    expect(boot.pageErrors).toEqual([]);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        trackedTokens: [MAINNET_TOKEN],
-    });
-
-    await boot.click("btn-settings");
-    await chooseNetwork(boot, "sepolia");
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([]);
-    expect(stored.networkTrackedTokens.mainnet).toEqual([MAINNET_TOKEN]);
-});
-
-// Another popup page stops tracking DAI on Ethereum Mainnet after this page's
-// last save. This page still holds DAI. The switch to Sepolia does not store
-// DAI under Ethereum Mainnet again.
-test("a token another page removed before a switch in Settings stays removed", async () => {
-    const boot = await bootPopup(
-        unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
-    );
-    expect(boot.pageErrors).toEqual([]);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        trackedTokens: [],
-    });
-
-    await boot.click("btn-settings");
-    await chooseNetwork(boot, "sepolia");
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([]);
-    expect(stored.networkTrackedTokens.mainnet).toEqual([]);
-});
-
-// Another popup page removes DAI after this page's last save. That page then
-// adds DAI again, typing the contract address in lower case. The two pages'
-// entries for DAI match, because contract addresses are compared ignoring
-// letter case. The switch to Sepolia keeps this page's entry under Ethereum
-// Mainnet.
-test("a token another page added again with a lower-case address keeps this page's entry", async () => {
-    const boot = await bootPopup(
-        unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
-    );
-    expect(boot.pageErrors).toEqual([]);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        trackedTokens: [
-            { ...MAINNET_TOKEN, address: MAINNET_TOKEN.address.toLowerCase() },
-        ],
-    });
-
-    await boot.click("btn-settings");
-    await chooseNetwork(boot, "sepolia");
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.networkTrackedTokens.mainnet).toEqual([MAINNET_TOKEN]);
-});
-
-// Another popup page saves a switch to Sepolia after this page's last save.
-// TST is tracked on Sepolia. This page has not taken that switch yet. A switch
-// to Sepolia in this page's Settings keeps TST off Ethereum Mainnet's list.
-test("a token tracked on Sepolia when another page switched there is not tracked on Ethereum Mainnet", async () => {
-    const boot = await bootPopup(unversionedValidProfile());
-    expect(boot.pageErrors).toEqual([]);
-    await boot.click("btn-settings");
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        networkId: "sepolia",
-        trackedTokens: [SEPOLIA_TOKEN],
-    });
-
-    await chooseNetwork(boot, "sepolia");
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN]);
-    expect(stored.networkTrackedTokens.mainnet).toEqual([]);
-});
-
-// Another popup page saves a switch to Sepolia, where TST is tracked. Before
-// taking that switch, this page adds a token on Ethereum Mainnet. The add's
-// save adds the token to Ethereum Mainnet's list and leaves Sepolia's list as
-// it was.
-test("a token added before this page takes another page's switch is tracked on Ethereum Mainnet", async () => {
-    const boot = await bootOnAddToken("mainnet", {
-        trackedTokens: [MAINNET_TOKEN],
-        networkTrackedTokens: { sepolia: [SEPOLIA_TOKEN] },
-    });
-    expect(boot.pageErrors).toEqual([]);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        networkId: "sepolia",
-        trackedTokens: [SEPOLIA_TOKEN],
-        networkTrackedTokens: {
-            mainnet: [MAINNET_TOKEN],
-            sepolia: [SEPOLIA_TOKEN],
-        },
-    });
-    const { lookupTokenInfo } = require("../src/shared/balances");
-    lookupTokenInfo.mockResolvedValueOnce({
-        symbol: "NEW",
-        decimals: 18,
-        name: "New Token",
-    });
-
-    boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
-    await boot.click("btn-settings-addtoken-manual");
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN]);
-    expect(stored.networkTrackedTokens.mainnet).toEqual([
-        MAINNET_TOKEN,
-        {
-            address: NEW_TOKEN_ADDRESS,
-            symbol: "NEW",
-            decimals: 18,
-            name: "New Token",
-            balanceNotFetched: true,
-        },
-    ]);
-});
-
-// Another popup page tracks DAI on Ethereum Mainnet and then saves a switch to
-// Sepolia. This page does not track DAI. Before taking that switch, this page
-// adds a token on Ethereum Mainnet. The add's save puts both DAI and the new
-// token on Ethereum Mainnet's list.
-test("a token added before this page takes another page's switch joins that page's tokens on Ethereum Mainnet", async () => {
-    const boot = await bootOnAddToken("mainnet");
-    expect(boot.pageErrors).toEqual([]);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        networkId: "sepolia",
-        trackedTokens: [],
-        networkTrackedTokens: { mainnet: [MAINNET_TOKEN] },
-    });
-    const { lookupTokenInfo } = require("../src/shared/balances");
-    lookupTokenInfo.mockResolvedValueOnce({
-        symbol: "NEW",
-        decimals: 18,
-        name: "New Token",
-    });
-
-    boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
-    await boot.click("btn-settings-addtoken-manual");
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([]);
-    expect(stored.networkTrackedTokens.mainnet).toEqual([
-        MAINNET_TOKEN,
-        {
-            address: NEW_TOKEN_ADDRESS,
-            symbol: "NEW",
-            decimals: 18,
-            name: "New Token",
-            balanceNotFetched: true,
-        },
-    ]);
-});
-
-// Another popup page saves a switch to Sepolia, where TST is tracked. Before
-// taking that switch, this page removes DAI on Ethereum Mainnet, as the `[x]`
-// on a tracked token in Settings does. The removal's save drops DAI from
-// Ethereum Mainnet's list and leaves Sepolia's list as it was.
-test("a token removed before this page takes another page's switch is gone from Ethereum Mainnet", async () => {
-    const boot = await bootPopup(
-        unversionedValidProfile({
-            trackedTokens: [MAINNET_TOKEN],
-            networkTrackedTokens: { sepolia: [SEPOLIA_TOKEN] },
-        }),
-    );
-    expect(boot.pageErrors).toEqual([]);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        networkId: "sepolia",
-        trackedTokens: [SEPOLIA_TOKEN],
-        networkTrackedTokens: {
-            mainnet: [MAINNET_TOKEN],
-            sepolia: [SEPOLIA_TOKEN],
-        },
-    });
-
-    const { state, saveState } = require("../src/shared/state");
-    state.trackedTokens.splice(0, 1);
-    await saveState();
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN]);
-    expect(stored.networkTrackedTokens.mainnet).toEqual([]);
-});
-
-// Another popup page tracks DAI on Ethereum Mainnet and then saves a switch to
-// Sepolia. That switch puts DAI away under Ethereum Mainnet. This page has not
-// taken the switch yet. A switch to Sepolia in this page's Settings keeps DAI
-// on Ethereum Mainnet's list.
-test("a token another page tracked before its own switch stays tracked on Ethereum Mainnet", async () => {
-    const boot = await bootPopup(unversionedValidProfile());
-    expect(boot.pageErrors).toEqual([]);
-    await boot.click("btn-settings");
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        networkId: "sepolia",
-        trackedTokens: [],
-        networkTrackedTokens: { mainnet: [MAINNET_TOKEN] },
-    });
-
-    await chooseNetwork(boot, "sepolia");
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.networkTrackedTokens.mainnet).toEqual([MAINNET_TOKEN]);
-});
-
-// This page switches to Sepolia. Another popup page has not taken that switch,
-// and its save adds a token to Ethereum Mainnet's list. This page switches back
-// and tracks that token.
-test("a token another page added on Ethereum Mainnet is tracked when this page switches back there", async () => {
-    const boot = await bootPopup(
-        unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
-    );
-    expect(boot.pageErrors).toEqual([]);
-    await boot.click("btn-settings");
-    await chooseNetwork(boot, "sepolia");
-    const newToken = {
-        address: NEW_TOKEN_ADDRESS,
-        symbol: "NEW",
-        decimals: 18,
-        name: "New Token",
-    };
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        networkTrackedTokens: { mainnet: [MAINNET_TOKEN, newToken] },
-    });
-
-    await chooseNetwork(boot, "mainnet");
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("mainnet");
-    expect(stored.trackedTokens).toEqual([MAINNET_TOKEN, newToken]);
-});
-
-// This page tracks DAI on Ethereum Mainnet and switches to Sepolia. Another
-// popup page has not taken that switch, and its save removes DAI from Ethereum
-// Mainnet's list. This page switches back and does not track DAI again.
-test("a token another page removed on Ethereum Mainnet stays removed when this page switches back there", async () => {
-    const boot = await bootPopup(
-        unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
-    );
-    expect(boot.pageErrors).toEqual([]);
-    await boot.click("btn-settings");
-    await chooseNetwork(boot, "sepolia");
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        networkTrackedTokens: { mainnet: [] },
-    });
-
-    await chooseNetwork(boot, "mainnet");
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("mainnet");
-    expect(stored.trackedTokens).toEqual([]);
-});
-
-// This page switches to Sepolia, where TST is tracked. Another popup page has
-// not taken that switch, and its save tracks DAI on Ethereum Mainnet. This page
-// then adds a token on Sepolia. Its save changes only `trackedTokens`, so DAI
-// stays on Ethereum Mainnet's list.
-test("a token another page added on Ethereum Mainnet stays when this page adds a token on Sepolia", async () => {
-    const boot = await bootOnAddToken("mainnet", {
-        networkTrackedTokens: { sepolia: [SEPOLIA_TOKEN] },
-    });
-    expect(boot.pageErrors).toEqual([]);
-    await gearSwitchBack(boot);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        networkTrackedTokens: {
-            mainnet: [MAINNET_TOKEN],
-            sepolia: [SEPOLIA_TOKEN],
-        },
-    });
-
-    const added = await addNewToken(boot);
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkTrackedTokens.mainnet).toEqual([MAINNET_TOKEN]);
-    expect(stored.networkTrackedTokens.sepolia).toEqual([SEPOLIA_TOKEN]);
-    expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN, added]);
-});
-
-// This page tracks DAI on Ethereum Mainnet and switches to Sepolia, where TST is
-// tracked. Another popup page has not taken that switch, and its save removes
-// DAI from Ethereum Mainnet's list. This page then adds a token on Sepolia. Its
-// save changes only `trackedTokens`, so DAI does not come back.
-test("a token another page removed on Ethereum Mainnet stays removed when this page adds a token on Sepolia", async () => {
-    const boot = await bootOnAddToken("mainnet", {
-        trackedTokens: [MAINNET_TOKEN],
-        networkTrackedTokens: { sepolia: [SEPOLIA_TOKEN] },
-    });
-    expect(boot.pageErrors).toEqual([]);
-    await gearSwitchBack(boot);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        networkTrackedTokens: { mainnet: [], sepolia: [SEPOLIA_TOKEN] },
-    });
-
-    const added = await addNewToken(boot);
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkTrackedTokens.mainnet).toEqual([]);
-    expect(stored.networkTrackedTokens.sepolia).toEqual([SEPOLIA_TOKEN]);
-    expect(stored.trackedTokens).toEqual([SEPOLIA_TOKEN, added]);
-});
-
-// Another popup page records a fraud contract on Ethereum Mainnet after this
-// page's last save. The switch to Sepolia drops that fraud contract, as the
-// switch drops this page's own.
-test("a fraud contract another page recorded before a switch in Settings is not kept on Sepolia", async () => {
-    const boot = await bootPopup(unversionedValidProfile());
-    expect(boot.pageErrors).toEqual([]);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        fraudContracts: [NEW_TOKEN_ADDRESS],
-    });
-
-    await boot.click("btn-settings");
-    await chooseNetwork(boot, "sepolia");
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.fraudContracts).toEqual([]);
-});
-
-// The contract lookup on SettingsAddToken answers on Ethereum Mainnet while the
-// switch to Sepolia waits for the lock. The page adds the token to Ethereum
-// Mainnet's list. The switch then keeps that list for Ethereum Mainnet.
-test("a token added while a switch in Settings waits for the lock stays tracked on Ethereum Mainnet", async () => {
-    const boot = await bootOnAddToken("mainnet");
-    expect(boot.pageErrors).toEqual([]);
-    const { lookupTokenInfo } = require("../src/shared/balances");
-    let answer;
-    lookupTokenInfo.mockImplementationOnce(
-        () =>
-            new Promise((resolve) => {
-                answer = resolve;
-            }),
-    );
-    boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
-    const adding = boot.click("btn-settings-addtoken-manual");
-    await boot.click("btn-settings");
-
-    // Another write holds the lock, so the switch's save waits for it.
-    let releaseLock;
-    const lockHeld = navigator.locks.request(
-        "autistmask",
-        () =>
-            new Promise((resolve) => {
-                releaseLock = resolve;
-            }),
-    );
-    const select = boot.node("settings-network");
-    select.value = "sepolia";
-    const switching = Promise.all(select.listeners.change.map((fn) => fn()));
-    await boot.settle();
-
-    answer({ symbol: "NEW", decimals: 18, name: "New Token" });
-    await boot.settle();
-    releaseLock();
-    await lockHeld;
-    await switching;
-    await adding;
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([]);
-    expect(stored.networkTrackedTokens.mainnet).toEqual([
-        {
-            address: NEW_TOKEN_ADDRESS,
-            symbol: "NEW",
-            decimals: 18,
-            name: "New Token",
-            balanceNotFetched: true,
-        },
-    ]);
-});
-
-// The contract lookup on SettingsAddToken answers on Ethereum Mainnet while
-// this page's switch to Sepolia waits for the lock. Another popup page holds
-// the lock and stores its own switch to Sepolia, with DAI tracked on Ethereum
-// Mainnet. This page's switch keeps DAI and the new token on Ethereum Mainnet's
-// list.
-test("a token added while a switch in Settings waits for another page's switch stays tracked on Ethereum Mainnet", async () => {
-    const boot = await bootOnAddToken("mainnet");
-    expect(boot.pageErrors).toEqual([]);
-    const { lookupTokenInfo } = require("../src/shared/balances");
-    let answer;
-    lookupTokenInfo.mockImplementationOnce(
-        () =>
-            new Promise((resolve) => {
-                answer = resolve;
-            }),
-    );
-    boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
-    const adding = boot.click("btn-settings-addtoken-manual");
-    await boot.click("btn-settings");
-
-    let releaseLock;
-    const lockHeld = navigator.locks.request(
-        "autistmask",
-        () =>
-            new Promise((resolve) => {
-                releaseLock = resolve;
-            }),
-    );
-    const select = boot.node("settings-network");
-    select.value = "sepolia";
-    const switching = Promise.all(select.listeners.change.map((fn) => fn()));
-    await boot.settle();
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        networkId: "sepolia",
-        trackedTokens: [],
-        networkTrackedTokens: { mainnet: [MAINNET_TOKEN] },
-    });
-
-    answer({ symbol: "NEW", decimals: 18, name: "New Token" });
-    await boot.settle();
-    releaseLock();
-    await lockHeld;
-    await switching;
-    await adding;
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([]);
-    expect(stored.networkTrackedTokens.mainnet).toEqual([
-        MAINNET_TOKEN,
-        {
-            address: NEW_TOKEN_ADDRESS,
-            symbol: "NEW",
-            decimals: 18,
-            name: "New Token",
-            balanceNotFetched: true,
-        },
-    ]);
-});
-
-// Another popup page holds the lock and stores its switch to Sepolia, with DAI
-// tracked on Ethereum Mainnet. This page waits for the lock to take that
-// switch. Meanwhile, the contract lookup on SettingsAddToken answers on
-// Ethereum Mainnet. When this page takes that switch, DAI and the new token
-// stay on Ethereum Mainnet's list.
-test("a token added while this page waits to take another page's switch stays tracked on Ethereum Mainnet", async () => {
-    const boot = await bootOnAddToken("mainnet");
-    expect(boot.pageErrors).toEqual([]);
-    let releaseLock;
-    const lockHeld = navigator.locks.request(
-        "autistmask",
-        () =>
-            new Promise((resolve) => {
-                releaseLock = resolve;
-            }),
-    );
-    await boot.storage.local.set({
-        autistmask: {
-            ...boot.storage.read("autistmask"),
-            networkId: "sepolia",
-            trackedTokens: [],
-            networkTrackedTokens: { mainnet: [MAINNET_TOKEN] },
-        },
-    });
-    await boot.settle();
-    const { lookupTokenInfo } = require("../src/shared/balances");
-    lookupTokenInfo.mockResolvedValueOnce({
-        symbol: "NEW",
-        decimals: 18,
-        name: "New Token",
-    });
-
-    boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
-    const adding = boot.click("btn-settings-addtoken-manual");
-    await boot.settle();
-    releaseLock();
-    await lockHeld;
-    await adding;
-    await boot.settle();
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([]);
-    expect(stored.networkTrackedTokens.mainnet).toEqual([
-        MAINNET_TOKEN,
-        {
-            address: NEW_TOKEN_ADDRESS,
-            symbol: "NEW",
-            decimals: 18,
-            name: "New Token",
-            balanceNotFetched: true,
-        },
-    ]);
-});
-
-// This page tracks DAI on Ethereum Mainnet. Another popup page holds the lock
-// and stores its switch to Sepolia, with DAI on Ethereum Mainnet's list. This
-// page waits for the lock to take that switch. Meanwhile, the user removes DAI,
-// as the `[x]` on a tracked token in Settings does. When this page takes that
-// switch, DAI is gone from Ethereum Mainnet's list.
-test("a token removed while this page waits to take another page's switch is gone from Ethereum Mainnet", async () => {
-    const boot = await bootPopup(
-        unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
-    );
-    expect(boot.pageErrors).toEqual([]);
-    let releaseLock;
-    const lockHeld = navigator.locks.request(
-        "autistmask",
-        () =>
-            new Promise((resolve) => {
-                releaseLock = resolve;
-            }),
-    );
-    await boot.storage.local.set({
-        autistmask: {
-            ...boot.storage.read("autistmask"),
-            networkId: "sepolia",
-            trackedTokens: [],
-            networkTrackedTokens: { mainnet: [MAINNET_TOKEN] },
-        },
-    });
-    await boot.settle();
-
-    const { state, saveState } = require("../src/shared/state");
-    state.trackedTokens.splice(0, 1);
-    const removing = saveState();
-    releaseLock();
-    await lockHeld;
-    await removing;
-    await boot.settle();
-
-    const stored = boot.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.trackedTokens).toEqual([]);
-    expect(stored.networkTrackedTokens.mainnet).toEqual([]);
-});
-
-// Another popup page tracks DAI after this page's last save. This page then
-// adds a token. Its save keeps DAI.
-test("a token another page added stays when this page adds a token", async () => {
-    const boot = await bootOnAddToken("mainnet");
-    expect(boot.pageErrors).toEqual([]);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        trackedTokens: [MAINNET_TOKEN],
-    });
-
-    const added = await addNewToken(boot);
-
-    expect(boot.storage.read("autistmask").trackedTokens).toEqual([
-        MAINNET_TOKEN,
-        added,
-    ]);
-});
-
-// Another popup page tracks a new token after this page's last save. This page
-// then removes DAI, as the `[x]` on a tracked token in Settings does. Its save
-// keeps the new token.
-test("a token another page added stays when this page removes a token", async () => {
-    const boot = await bootPopup(
-        unversionedValidProfile({ trackedTokens: [MAINNET_TOKEN] }),
-    );
-    expect(boot.pageErrors).toEqual([]);
-    const otherPageToken = {
-        address: NEW_TOKEN_ADDRESS,
-        symbol: "NEW",
-        decimals: 18,
-        name: "New Token",
-    };
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        trackedTokens: [MAINNET_TOKEN, otherPageToken],
-    });
-
-    const { state, saveState } = require("../src/shared/state");
-    state.trackedTokens.splice(0, 1);
-    await saveState();
-
-    expect(boot.storage.read("autistmask").trackedTokens).toEqual([
-        otherPageToken,
-    ]);
-});
-
-// Another popup page stops tracking DAI after this page's last save. This page
-// still holds DAI and adds a token. Its save does not store DAI again.
-test("a token another page removed stays removed when this page adds a token", async () => {
-    const boot = await bootOnAddToken("mainnet", {
-        trackedTokens: [MAINNET_TOKEN],
-    });
-    expect(boot.pageErrors).toEqual([]);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        trackedTokens: [],
-    });
-
-    const added = await addNewToken(boot);
-
-    expect(boot.storage.read("autistmask").trackedTokens).toEqual([added]);
-});
-
-// Another popup page tracks DAI and the new token after this page's last save,
-// and its refresh has read the new token's balance. This page adds the new token
-// too, so the two pages hold different records for it. The save stores one
-// record for the new token, this page's, and keeps DAI.
-test("a token both pages added is stored once, with this page's record", async () => {
-    const boot = await bootOnAddToken("mainnet");
-    expect(boot.pageErrors).toEqual([]);
-    boot.storage.write("autistmask", {
-        ...boot.storage.read("autistmask"),
-        trackedTokens: [
-            MAINNET_TOKEN,
-            {
-                address: NEW_TOKEN_ADDRESS,
-                symbol: "NEW",
-                decimals: 18,
-                name: "New Token",
-            },
-        ],
-    });
-
-    const added = await addNewToken(boot);
-
-    expect(boot.storage.read("autistmask").trackedTokens).toEqual([
-        MAINNET_TOKEN,
-        added,
-    ]);
-});
-
-// This page and the stored list each hold DAI twice. This page then adds a
-// token. Its save stores DAI once.
-test("a token held twice is stored once when this page adds a token", async () => {
-    const boot = await bootOnAddToken("mainnet", {
-        trackedTokens: [MAINNET_TOKEN, MAINNET_TOKEN],
-    });
-    expect(boot.pageErrors).toEqual([]);
-
-    const added = await addNewToken(boot);
-
-    expect(boot.storage.read("autistmask").trackedTokens).toEqual([
-        MAINNET_TOKEN,
-        added,
-    ]);
-});
-
 describe("Back after a switch from the Settings gear", () => {
     test("SettingsAddToken no longer offers the common tokens", async () => {
         const boot = await bootOnAddToken("mainnet");

tests/transactionDetailLateAnswer.test.js

@@ -1,202 +0,0 @@
-// TransactionDetail shows only details that Blockscout gave for the
-// transaction on screen (https://git.eeqj.de/sneak/AutistMask/issues/675).
-//
-// The screen asks Blockscout for its transaction and does not wait for the
-// answer. So the user can press Back and open another transaction before
-// Blockscout answers for the first. The first answer must then fill nothing on
-// the second transaction's screen. An answer that lands while Settings is up
-// must still fill TransactionDetail.
-//
-// Driven through the real popup over a stored profile
-// (tests/support/popupBoot.js). Each transaction is opened as a history screen
-// opens it: the current screen is pushed, then transactionDetail.show() draws
-// the transaction.
-
-"use strict";
-
-const {
-    bootPopup,
-    cleanupPopup,
-    unversionedValidProfile,
-    ADDRESS,
-} = require("./support/popupBoot");
-
-const MAINNET_BLOCKSCOUT = "https://eth.blockscout.com/api/v2";
-const SEPOLIA_BLOCKSCOUT = "https://eth-sepolia.blockscout.com/api/v2";
-const RECIPIENT = "0x2222222222222222222222222222222222222222";
-
-// A history entry for a send of 1 `symbol` from ADDRESS to RECIPIENT, on the
-// network with `chainId`.
-function historyEntry(hash, chainId, symbol) {
-    return {
-        hash,
-        from: ADDRESS,
-        to: RECIPIENT,
-        value: "1.0000",
-        exactValue: "1.0",
-        symbol,
-        timestamp: 1790000000,
-        isError: false,
-        direction: "sent",
-        directionLabel: "Sent",
-        contractAddress: null,
-        chainId,
-    };
-}
-
-const FIRST = historyEntry("0x" + "aa".repeat(32), "0x1", "ETH");
-const SECOND = historyEntry("0x" + "bb".repeat(32), "0x1", "ETH");
-// A transaction on Sepolia with the same hash as FIRST.
-const FIRST_ON_SEPOLIA = historyEntry(FIRST.hash, "0xaa36a7", "SepoliaETH");
-
-// The URL that asks Blockscout for `entry`, on the network it was sent on.
-function requestUrl(entry) {
-    const blockscout =
-        entry.chainId === "0x1" ? MAINNET_BLOCKSCOUT : SEPOLIA_BLOCKSCOUT;
-    return blockscout + "/transactions/" + entry.hash;
-}
-
-// What Blockscout reports for each transaction, by the URL that asks for it.
-const ANSWERS = {
-    [requestUrl(FIRST)]: {
-        block_number: 21000001,
-        nonce: 4441,
-        fee: { value: "21000000000000" },
-        raw_input: "0x11111111",
-        method: "firstMethod",
-    },
-    [requestUrl(SECOND)]: {
-        block_number: 21000002,
-        nonce: 4442,
-        fee: { value: "42000000000000" },
-        raw_input: "0x22222222",
-        method: "secondMethod",
-    },
-    [requestUrl(FIRST_ON_SEPOLIA)]: {
-        block_number: 21000003,
-        nonce: 4443,
-        fee: { value: "63000000000000" },
-        raw_input: "0x33333333",
-        method: "sepoliaMethod",
-    },
-};
-
-// The text each answer puts on screen: its block, nonce, fee, method name and
-// raw data. No text from one answer appears in another.
-const FIRST_SHOWN = [
-    "21000001",
-    "4441",
-    "0.000021 ETH",
-    "firstMethod",
-    "0x11111111",
-];
-const SECOND_SHOWN = [
-    "21000002",
-    "4442",
-    "0.000042 ETH",
-    "secondMethod",
-    "0x22222222",
-];
-const FIRST_ON_SEPOLIA_SHOWN = [
-    "21000003",
-    "4443",
-    "0.000063 SepoliaETH",
-    "sepoliaMethod",
-    "0x33333333",
-];
-
-// Everything drawn in the fields that Blockscout's answer fills.
-function drawnDetails(page) {
-    return [
-        "tx-detail-block",
-        "tx-detail-nonce",
-        "tx-detail-fee",
-        "tx-detail-calldata-action",
-        "tx-detail-rawdata",
-    ]
-        .map((id) => page.node(id).innerHTML + page.node(id).textContent)
-        .join("\n");
-}
-
-// Opens `entry` on TransactionDetail, as a history screen does.
-function open(entry) {
-    require("../src/popup/views/helpers").pushCurrentView();
-    require("../src/popup/views/transactionDetail").show(entry);
-}
-
-// The URLs of every request to Blockscout so far, in order.
-function requestedUrls() {
-    return globalThis.fetch.mock.calls.map(([url]) => url);
-}
-
-// Boots the popup on Home with "Use Blockscout" on. Blockscout answers every
-// request at once from ANSWERS, except the request for `held`. Returns the
-// page and answer(), which lets the answer for `held` land.
-async function bootWithHeldRequest(held) {
-    const page = await bootPopup(
-        unversionedValidProfile({ useBlockscout: true }),
-    );
-    let answer;
-    const heldAnswer = new Promise((resolve) => {
-        answer = resolve;
-    });
-    globalThis.fetch = jest.fn(async (url) => {
-        if (url === requestUrl(held)) await heldAnswer;
-        return { ok: true, status: 200, json: async () => ANSWERS[url] };
-    });
-    return { page, answer: () => answer() };
-}
-
-// The user opens `first`, whose request to Blockscout is held. Then the user
-// presses Back and opens `second`. Then the answer for `first` lands. Returns
-// the page.
-async function firstAnswerLandsOnSecond(first, second) {
-    const { page, answer } = await bootWithHeldRequest(first);
-    open(first);
-    await page.settle();
-    await page.click("btn-tx-back");
-    expect(page.visibleViews()).toEqual(["main"]);
-    open(second);
-    await page.settle();
-    expect(requestedUrls()).toEqual([requestUrl(first), requestUrl(second)]);
-    answer();
-    await page.settle();
-    expect(page.visibleViews()).toEqual(["transaction"]);
-    return page;
-}
-
-afterEach(() => {
-    cleanupPopup();
-});
-
-test("an answer for the first transaction that lands on the second one's screen fills nothing", async () => {
-    const page = await firstAnswerLandsOnSecond(FIRST, SECOND);
-
-    const drawn = drawnDetails(page);
-    for (const text of SECOND_SHOWN) expect(drawn).toContain(text);
-    for (const text of FIRST_SHOWN) expect(drawn).not.toContain(text);
-});
-
-test("an answer for a hash on mainnet that lands on the same hash's screen on Sepolia fills nothing", async () => {
-    const page = await firstAnswerLandsOnSecond(FIRST, FIRST_ON_SEPOLIA);
-
-    const drawn = drawnDetails(page);
-    for (const text of FIRST_ON_SEPOLIA_SHOWN) expect(drawn).toContain(text);
-    for (const text of FIRST_SHOWN) expect(drawn).not.toContain(text);
-});
-
-test("an answer that lands while Settings is up still fills TransactionDetail", async () => {
-    const { page, answer } = await bootWithHeldRequest(FIRST);
-    open(FIRST);
-    await page.settle();
-    await page.click("btn-settings");
-    expect(page.visibleViews()).toEqual(["settings"]);
-    answer();
-    await page.settle();
-    await page.click("btn-settings");
-
-    expect(page.visibleViews()).toEqual(["transaction"]);
-    expect(requestedUrls()).toEqual([requestUrl(FIRST)]);
-    const drawn = drawnDetails(page);
-    for (const text of FIRST_SHOWN) expect(drawn).toContain(text);
-});

tests/transactions.test.js

@@ -144,7 +144,6 @@ function tokenTx(overrides = {}) {
         isError: false,
         contractAddress: USDC_CONTRACT,
         holders: 3500000,
-        chainId: "0x1",
         ...overrides,
     };
 }
@@ -260,32 +259,6 @@ describe("known-symbol spoof verification", () => {
         expect(result.newFraudContracts).toEqual([NOVEL_SPAM_CONTRACT]);
     });
 
-    // https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled list holds
-    // mainnet contracts, so its symbols are not known symbols on Sepolia.
-    test("on Sepolia, a bundled symbol from another contract is kept", () => {
-        const sepoliaToken = tokenTx({
-            symbol: "USDC",
-            contractAddress: NOVEL_SPAM_CONTRACT,
-            holders: 5000000,
-            chainId: "0xaa36a7",
-        });
-        const result = filterTransactions([sepoliaToken], filters());
-        expect(result.transactions).toEqual([sepoliaToken]);
-        expect(result.newFraudContracts).toEqual([]);
-    });
-
-    test('on Sepolia, "ETH" as an ERC-20 is still spoofed', () => {
-        const fakeEth = tokenTx({
-            symbol: "ETH",
-            contractAddress: NOVEL_SPAM_CONTRACT,
-            holders: 5000000,
-            chainId: "0xaa36a7",
-        });
-        expect(filterTransactions([fakeEth], filters()).transactions).toEqual(
-            [],
-        );
-    });
-
     test("the genuine contract for that symbol is not spoofed", () => {
         const genuine = tokenTx();
         const result = filterTransactions([genuine], filters());
@@ -1522,41 +1495,6 @@ describe("fetchRecentTransactions merge and dedup", () => {
         expect(mainnet[0].chainId).toBe("0x1");
     });
 
-    // https://git.eeqj.de/sneak/AutistMask/issues/632: the bundled token list
-    // names a contract only on Ethereum Mainnet. On Sepolia, a call to the
-    // contract at USDC's mainnet address is labelled with the network's native
-    // currency. A call to any contract the wallet does not name gets that label.
-    test("a contract call on Sepolia is not named by the bundled list", async () => {
-        respondWith(
-            [
-                {
-                    hash: "0x" + "b".repeat(64),
-                    block_number: 21000095,
-                    timestamp: TS,
-                    from: { hash: VICTIM },
-                    to: { hash: USDC_CONTRACT, is_contract: true },
-                    value: "0",
-                    method: "approve",
-                    status: "ok",
-                },
-            ],
-            [],
-        );
-        const sepolia = await fetchRecentTransactions(
-            VICTIM,
-            BLOCKSCOUT,
-            "0xaa36a7",
-        );
-        expect(sepolia[0].directionLabel).toBe("Approve");
-        expect(sepolia[0].symbol).toBe("SepoliaETH");
-        const mainnet = await fetchRecentTransactions(
-            VICTIM,
-            BLOCKSCOUT,
-            "0x1",
-        );
-        expect(mainnet[0].symbol).toBe("USDC");
-    });
-
     test("the fake token transfer survives fetching and is then filtered", async () => {
         respondWith(
             [],

tests/txStatus.test.js

@@ -672,86 +672,6 @@ describe("SuccessTx and ErrorTx for a Sepolia transaction with mainnet active",
     });
 });
 
-describe("the Moved from the sender lines of a swap on WaitTx and ErrorTx", () => {
-    const moved = (value) => ({ label: "Moved from the sender", value });
-    const decoded = {
-        details: [
-            moved("Up to 1.0000 ETH"),
-            { label: "Token moved", value: "ETH" },
-            moved("<b>400.0000</b> DAI"),
-        ],
-    };
-
-    function expectEveryLine(id) {
-        const html = getElement(id).innerHTML;
-        expect(html).toContain("Up to 1.0000 ETH");
-        expect(html).toContain("&lt;b&gt;400.0000&lt;/b&gt; DAI");
-        expect(html).not.toContain("Token moved");
-    }
-
-    test("WaitTx shows each line's amount, escaped", () => {
-        mockReceiptLookup.mockResolvedValue(null);
-        txStatus.showWait({ ...TX_INFO, decoded }, TX_HASH);
-        expectEveryLine("wait-tx-token-note");
-    });
-
-    test("ErrorTx shows each line's amount, escaped", () => {
-        txStatus.showError({ ...TX_INFO, decoded }, TX_HASH, "It failed.");
-        expectEveryLine("error-tx-token-note");
-    });
-
-    test("a wait that ends in ErrorTx keeps them", async () => {
-        mockReceiptLookup.mockResolvedValue(null);
-        txStatus.showWait({ ...TX_INFO, decoded }, TX_HASH);
-        await jest.advanceTimersByTimeAsync(60000);
-        expect(state.currentView).toBe("error-tx");
-        expectEveryLine("error-tx-token-note");
-    });
-
-    // A saved record comes back from storage, in whatever shape it is in. A
-    // throw here would leave the popup's restore unfinished.
-    test("a saved record in another shape shows only the lines it can read", () => {
-        mockReceiptLookup.mockResolvedValue(null);
-        function noteOnReopen(saved) {
-            state.viewData = {
-                pendingWait: {
-                    hash: TX_HASH,
-                    txInfo: { ...TX_INFO, decoded: saved },
-                    broadcastTime: Date.now(),
-                },
-            };
-            expect(txStatus.restoreWait()).toBe(true);
-            const waitNote = getElement("wait-tx-token-note").innerHTML;
-            txStatus.endWait();
-
-            state.viewData = {
-                message: "It failed.",
-                to: RECIPIENT,
-                chainId: TX_INFO.chainId,
-                decoded: saved,
-            };
-            txStatus.renderError();
-            expect(getElement("error-tx-token-note").innerHTML).toBe(waitNote);
-            return waitNote;
-        }
-
-        for (const saved of [
-            7,
-            "text",
-            { details: 7 },
-            { details: [null] },
-            { details: [{ label: "Moved from the sender" }] },
-            { details: [moved(7)] },
-            { details: [moved({ toString: 1 })] },
-        ]) {
-            expect(noteOnReopen(saved)).toBe("");
-        }
-        expect(
-            noteOnReopen({ details: [null, moved("Up to 1.0000 ETH")] }),
-        ).toContain("Up to 1.0000 ETH");
-    });
-});
-
 describe("wait-tx is a view the popup may reopen onto", () => {
     // The resume feature is wired through RESTORABLE_VIEWS: restoreView()
     // refuses any view not in the set, so dropping "wait-tx" from it kills

tests/uniswapRecipient.test.js

@@ -370,8 +370,7 @@ const PAID_ELSEWHERE = [
     "Steps",
     "Deadline",
 ];
-// `lines` with the lines of one PERMIT2_TRANSFER_FROM or later WRAP_ETH after
-// Amount.
+// `lines` with the lines of one PERMIT2_TRANSFER_FROM after Amount.
 const withMove = (lines) =>
     lines.flatMap((l) =>
         l === "Amount"
@@ -689,62 +688,6 @@ describe("an UNWRAP_WETH makes the output ETH only when the router holds it", ()
         ]);
     });
 
-    // The same route, then a balance check of the sender's USDC with a zero
-    // minimum. The check guarantees nothing, so Token Out stays ETH
-    // (https://git.eeqj.de/sneak/AutistMask/issues/649).
-    test("the same route, then a zero balance check of USDC, still reads as ETH with no minimum", () => {
-        const result = decode(
-            execute(
-                v4Swap(
-                    SWAP_USDT_FOR_WETH,
-                    SETTLE_USDT,
-                    take(WETH, MSG_SENDER, (ONE_WETH * 6n) / 10n),
-                    take(WETH, ADDRESS_THIS),
-                ),
-                unwrapWeth(MSG_SENDER),
-                balanceCheck(USDC, 0n),
-            ),
-        );
-        expect(result.name).toBe("Swap USDT → ETH");
-        expect(detail(result, "Token Out").value).toBe("ETH");
-        expect(labels(result)).toEqual([
-            "Protocol",
-            "Token In",
-            "Amount",
-            "Token Out",
-            "Steps",
-            "Deadline",
-        ]);
-    });
-
-    // A PERMIT2_TRANSFER_FROM moves the sender's WETH into the router. An
-    // UNWRAP_WETH pays that WETH to the user as ETH. A zero balance check of
-    // USDC sets neither Token Out nor the minimum, before the UNWRAP_WETH or
-    // after it (https://git.eeqj.de/sneak/AutistMask/issues/649).
-    test.each([
-        {
-            kind: "before the UNWRAP_WETH",
-            steps: [balanceCheck(USDC, 0n), unwrapWeth(MSG_SENDER)],
-        },
-        {
-            kind: "after the UNWRAP_WETH",
-            steps: [unwrapWeth(MSG_SENDER), balanceCheck(USDC, 0n)],
-        },
-    ])(
-        "WETH moved into the router and unwrapped, with a zero balance check of USDC $kind, reads as ETH with no minimum",
-        ({ steps }) => {
-            const result = decode(
-                execute(
-                    permit2TransferFrom(WETH, ADDRESS_THIS, ONE_WETH),
-                    ...steps,
-                ),
-            );
-            expect(detail(result, "Token Out").value).toBe("ETH");
-            expect(detail(result, "Min. received")).toBeUndefined();
-            expect(detail(result, "Min. paid out")).toBeUndefined();
-        },
-    );
-
     // A TAKE the decoder cannot read may pay part of the WETH to the user.
     test("one V4 step paying WETH to the router beside a TAKE that cannot be read, then an UNWRAP_WETH, reads as ETH with no minimum", () => {
         const result = decode(
@@ -986,7 +929,7 @@ describe("what reaches the UNWRAP_WETH of the swap's WETH", () => {
     );
 
     // The SWEEP pays the user the swap's WETH, so the UNWRAP_WETH unwraps the
-    // WRAP_ETH's. The WRAP_ETH's 1 ETH gets lines of its own.
+    // WRAP_ETH's.
     test("a SWEEP of the swap's WETH to the user, then a WRAP_ETH into the router, reads as ETH with no minimum", () => {
         const result = decode(
             execute(
@@ -997,10 +940,7 @@ describe("what reaches the UNWRAP_WETH of the swap's WETH", () => {
             ),
         );
         expect(result.name).toBe("Swap USDT → ETH");
-        expect(labels(result)).toEqual(withMove(NO_MINIMUM_TO_USER));
-        expect(detail(result, "Moved from the sender").value).toBe(
-            "1.0000 ETH",
-        );
+        expect(labels(result)).toEqual(NO_MINIMUM_TO_USER);
     });
 
     test("an UNWRAP_WETH into the router, then a WRAP_ETH of all its ETH to the user, reads as WETH with no minimum", () => {
@@ -1101,9 +1041,7 @@ describe("what reaches the UNWRAP_WETH of the swap's WETH", () => {
         },
     );
 
-    // The user receives 0.5 WETH and the rest of the swap's output as ETH. The
-    // router holds ETH when the WRAP_ETH runs, so the sender pays at most its
-    // 0.5 ETH.
+    // The user receives 0.5 WETH and the rest of the swap's output as ETH.
     test("an UNWRAP_WETH into the router, then a WRAP_ETH of 0.5 ETH to the user, reads as WETH with no minimum", () => {
         const result = decode(
             execute(
@@ -1114,11 +1052,7 @@ describe("what reaches the UNWRAP_WETH of the swap's WETH", () => {
             ),
         );
         expect(result.name).toBe("Swap USDT → WETH");
-        expect(labels(result)).toEqual(withMove(NO_MINIMUM_TO_USER));
-        expect(detail(result, "Moved from the sender").value).toBe(
-            "Up to 0.5000 ETH",
-        );
-        expect(detail(result, "Moved to").value).toBe("The sender");
+        expect(labels(result)).toEqual(NO_MINIMUM_TO_USER);
     });
 
     // The UNWRAP_WETH pays the user the swap's WETH as ETH; the WRAP_ETH wraps
@@ -1358,7 +1292,6 @@ describe("any token left in the router is not received", () => {
                 ),
             ),
             left: tokenLine(WETH, "WETH"),
-            spent: "1.0000 ETH",
         },
         // A SETTLE of OPEN_DELTA from the router pays only what the step
         // still owes of its currency when it runs.
@@ -1527,8 +1460,8 @@ describe("any token left in the router is not received", () => {
                       "Moved from the sender",
                   ]
                 : ["Amount"]),
-            // A later swap step or WRAP_ETH the user pays for spends `spent`
-            // of a token other than Token In.
+            // A later swap step the user pays for spends `spent` of a token
+            // other than Token In.
             ...(spent
                 ? ["Moved from the sender", "Token moved", "Moved to"]
                 : []),
@@ -1728,18 +1661,9 @@ describe("any token left in the router is not received", () => {
             ),
             min: "1990.0000 USDC",
         },
-    ])("$kind reads as a swap paid to the user", ({ data, min }) => {
-        const result = decode(data);
-        expect(labels(result)).toEqual(PAID_TO_USER);
-        expect(detail(result, "Min. received").value).toBe(min);
-    });
-
-    // https://git.eeqj.de/sneak/AutistMask/issues/682 — the SETTLE spends all
-    // the router's ETH, the transaction's value included, so the sender pays
-    // an amount the calldata does not state.
-    test("a swap paying WETH to the router, an UNWRAP_WETH into the router, then a V4 swap settling all the ETH from the router reads as a swap paid to the user", () => {
-        const result = decode(
-            execute(
+        {
+            kind: "a swap paying WETH to the router, an UNWRAP_WETH into the router, then a V4 swap settling all the ETH from the router",
+            data: execute(
                 swapToWeth(ADDRESS_THIS),
                 unwrapWeth(ADDRESS_THIS),
                 v4Swap(
@@ -1748,23 +1672,12 @@ describe("any token left in the router is not received", () => {
                     takeAll(USDC),
                 ),
             ),
-        );
-        expect(labels(result)).toEqual([
-            "Protocol",
-            "Token In",
-            "Amount",
-            "Moved from the sender",
-            "Token moved",
-            "Moved to",
-            "Token Out",
-            "Min. received",
-            "Steps",
-            "Deadline",
-        ]);
-        expect(detail(result, "Moved from the sender").value).toBe(
-            "Unknown (could not be decoded)",
-        );
-        expect(detail(result, "Min. received").value).toBe("1990.0000 USDC");
+            min: "1990.0000 USDC",
+        },
+    ])("$kind reads as a swap paid to the user", ({ data, min }) => {
+        const result = decode(data);
+        expect(labels(result)).toEqual(PAID_TO_USER);
+        expect(detail(result, "Min. received").value).toBe(min);
     });
 });
 
@@ -2887,16 +2800,17 @@ describe("the allow-revert flag", () => {
         },
     );
 
-    test("a BALANCE_CHECK_ERC20 with the flag, and no minimum before it, names no output token and no minimum", () => {
+    test("a BALANCE_CHECK_ERC20 with the flag, and no minimum before it, states none", () => {
         const check = balanceCheck(WETH, ONE_WETH);
         expect(detail(decode(execute(check)), "Min. paid out").value).toBe(
             "1.0000 WETH",
         );
 
         const withFlag = decode(execute(flagged(check)));
-        expect(detail(withFlag, "Token Out").value).toBe(UNNAMED);
-        expect(detail(withFlag, "Min. paid out")).toBeUndefined();
-        expect(detail(withFlag, "Min. received")).toBeUndefined();
+        expect(detail(withFlag, "Token Out").address).toBe(WETH);
+        expect(detail(withFlag, "Min. paid out").value).toBe(
+            "None (no minimum guaranteed)",
+        );
     });
 
     // Only the routers from UniversalRouterV2 on let a PERMIT2_PERMIT fail.

tests/unknownScaleDisplay.test.js

@@ -103,7 +103,7 @@ describe("balanceLine", () => {
     });
 
     test("an unknown quantity produces no fiat figure, a zero one does", () => {
-        prices[NOVEL] = 3;
+        prices.NOVEL = 3;
         const unknown = balanceLine("NOVEL", null, 3, NOVEL);
         const zero = balanceLine("NOVEL", 0, 3, NOVEL);
         // A price times an unknown quantity is not $0.00: that is the same
@@ -162,7 +162,7 @@ describe("getAddressValue", () => {
     // make it incomplete.
     test("an unknown balance makes the total partial, a zero balance does not", () => {
         prices.ETH = 2000;
-        prices[NOVEL] = 3;
+        prices.NOVEL = 3;
         const unknown = getAddressValue(address(null));
         const zero = getAddressValue(address("0.0"));
         expect(unknown).not.toEqual(zero);
@@ -172,7 +172,7 @@ describe("getAddressValue", () => {
 
     test("an unknown balance is not priced as zero of the token", () => {
         prices.ETH = 2000;
-        prices[NOVEL] = 3;
+        prices.NOVEL = 3;
         // The same row with a real quantity of 10 is worth $30. Neither that
         // figure nor a confident $0.00 may be stated for the unknown one.
         expect(getAddressValue(address("10.0"))).toEqual({

tests/unknownScaleSend.test.js

@@ -167,8 +167,7 @@ function row(token = {}, value = FIVE_WETH) {
 }
 
 // Fetch the explorer's rows through the real fetcher and put them exactly where
-// refreshBalances() puts them on Ethereum Mainnet. The node reports the holding
-// the explorer does.
+// refreshBalances() puts them. The node reports the holding the explorer does.
 async function fetchOnto(items) {
     mockProvider.tokenUnits = BigInt(items[0].value);
     debugFetch.mockImplementation(async () => ({
@@ -177,7 +176,7 @@ async function fetchOnto(items) {
         statusText: "OK",
         json: async () => items,
     }));
-    const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, [], "0x1");
+    const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, []);
     state.wallets = [
         {
             name: "Wallet 1",

tests/walletDefects.test.js

@@ -357,11 +357,6 @@ describe("every way to a signature or the private key refuses a defective wallet
     });
 
     beforeEach(() => {
-        // showFlash() starts a timer that clears the message two seconds
-        // later. Each test here runs on fake timers and drops them in
-        // afterEach, so that timer never outlives the test.
-        jest.useFakeTimers();
-
         const broken = brokenXprvWallet();
         // A balance, so that no Send button's zero-balance refusal can stand
         // in for the defect check.
@@ -403,7 +398,6 @@ describe("every way to a signature or the private key refuses a defective wallet
     });
 
     afterEach(() => {
-        jest.useRealTimers();
         state.wallets = [];
         state.activeAddress = null;
         state.selectedWallet = null;