security: announce a fresh EIP-6963 provider UUID per page load (closes #398 )

The provider UUID was generated once, stored in extension storage, and announced verbatim to every page on every load and across restarts, so any site — connected or not — could read a stable cross-site, cross-session identifier for the install: a supercookie contradicting the "no tracking" promise. EIP-6963 wants a fresh UUIDv4 per announcement instead. inpage.js now announces a per-load crypto.randomUUID() and persists nothing; the eip6963Uuid storage key and the AUTISTMASK_PROVIDER_UUID content-script message are removed. That key was a standalone top-level storage entry, never part of the versioned autistmask profile, so stateSchema.js and the persisted-field harness are untouched and no existing profile is affected. A jest test asserts two loads announce different UUIDv4s and that one load reuses a single UUID across re-announcements. Model: opus-4-8
fix: re-enable Confirm Delete after a delete, so a second one needs no reopen (closes #335 )
2026-09-21 23:35:57 +00:00 · 2026-09-22 01:28:02 +02:00 · 2026-09-22 00:45:06 +02:00 · 2026-09-21 22:00:18 +02:00 · 2026-09-21 21:45:34 +02:00 · 2026-09-21 21:28:06 +02:00
61 changed files with 3607 additions and 428 deletions
@@ -64,7 +64,9 @@ release/SHA256SUMS
 ```

 Nothing is published by this. Tagging, CRX packing and any upload are
-outward-facing acts and are the owner's alone.
+outward-facing acts and are the owner's alone. The full procedure that turns a
+green `main` into a tagged, packaged release — the order of steps, who performs
+each, and how to check it worked — is in [docs/RELEASE.md](docs/RELEASE.md).

 The archives are deterministic — entries sorted, timestamps fixed, compression
 level fixed — so two builds of one commit produce byte-identical files and the
@@ -800,7 +802,12 @@ discoverable.
  addresses visually, as a security feature.
 - **Tailwind CSS**: Utility-first CSS via Tailwind. No custom CSS classes for
  styling. Tailwind is configured with a minimal monochrome palette. This keeps
-  the styling co-located with the markup and eliminates CSS file management.
+  the styling co-located with the markup and eliminates CSS file management. The
+  handful of classes in `styles/main.css` are not styling: `.copy-flash-*`
+  carries the copy feedback animation, and `.am-address` carries the rule that
+  an address never wraps. Both are invariants that hold in every place they
+  appear, and spelling either out as repeated utilities is how one of those
+  places drifts away from the rest.
 - **Vanilla JS**: No framework (React, Vue, Svelte, etc.). The popup UI is small
  enough that vanilla JS with simple view switching is sufficient. A framework
  would add bundle size, build complexity, and attack surface for no benefit at
@@ -849,6 +856,12 @@ that the portions still displayed will be more than adequate for the user to
 verify addresses even in the case of address spoofing attacks. Clicking an
 address will always copy the full, untruncated value.

+As of the address-row layout change, no view invokes that exception: every
+address in the popup is rendered on a row of its own, wide enough for all 42
+characters, and no screen truncates one to fit. The cap is still enforced in
+`truncateMiddle()` and the 32-character floor in `renderAddressHtml()`, so the
+guarantee holds for any future caller; there simply are none today.
+
 **Specific Exception — Transaction Detail view:** The transaction detail screen
 is the authoritative record of a specific transaction and shows the exact,
 untruncated amount with all meaningful decimal places (e.g. "0.00498824598498216
@@ -902,6 +915,27 @@ the swap's `Amount` and `Min. received` lines (`src/shared/uniswap.js`). An
 unbounded allowance or permit needs no scale to describe and is still shown as
 `Unlimited`.

+The rule holds only if nothing invents a scale UPSTREAM of it. Those three
+sources are read as authoritative, so a value written into one of them cannot be
+recognized as a guess afterwards: a fabricated `18` reads exactly like a real
+`18`, and the refusal above then never fires. So `fetchTokenBalances()` in
+`src/shared/balances.js` stores what the explorer reported or `null`, never a
+default, and the same holds for the history list's token transfers in
+`src/shared/transactions.js`. A token whose `decimals()` reverts has no scale
+anywhere, and a holding of it carries no quantity either: its balance is `null`
+— read as unknown, never as zero — and the balance list says so rather than
+printing `0.0000` for money that is really there. `0` is a real scale and is
+never treated as absent.
+
+`tokenBalances[].decimals` is therefore the explorer's own answer and nothing
+else, which is not the same question as the scale a screen should render at.
+Anything that needs the second one calls `resolveTokenDecimals()` — the balance
+list, the approval and swap lines, and the Send screen, which carries the
+resolved scale onto the pending transaction for `transferAmount.js` to encode
+and compare against. Reading the stored field directly instead answers `null`
+for a bundled or tracked token the explorer merely omitted, which is not a
+refusal the wallet has any reason to make.
+
 #### Partial USD totals

 Prices are fetched for the top 25 tokens only, so an address can hold assets the
@@ -1027,12 +1061,24 @@ because nothing dereferences them structurally.
 Which field is which is not written in prose anywhere, deliberately.
 `tests/persistedFieldContract.test.js` is the list: one row per persisted field,
 naming the property that field's floor is claimed to have and proving it by
-driving the real code with hostile values — including a boot of the real popup
-entry point for every field whose only defence is that nothing dereferences it.
-A field added to `PERSISTED_FIELDS` with no row fails `make check`, and so does
-a row whose claim is false. The per-field justification that used to live in the
-header of `src/shared/stateSchema.js` shipped a false claim in three consecutive
-changes, each caught only by a reviewer re-deriving thirty fields by hand.
+driving the real code with hostile values — and, for every field whose only
+defence is that nothing dereferences it, by booting the real popup entry point
+over that value onto every view the popup can reopen onto. That last part is
+what makes the claim falsifiable, because this defect class lives on the restore
+path rather than on the home screen. Read the claim narrowly, as that file
+states it: what those boots prove is no structural dereference on the code paths
+a WHOLLY-CORRUPTED PROFILE takes, which is not every path a stored record takes.
+Not driven: any pairing of values the four slots do not produce, a view only
+forward navigation opens, anything behind a click, and everything a healthy
+profile reaches. Within that boundary the verdict is unconditional — if one of
+those boots leaves the popup unhealthy or off the view it stored, `make check`
+fails, including when it takes two corrupted fields at once, because the verdict
+is the combined boot and the per-field re-boot that names a culprit can only
+decorate the message. So does a field that gains a floor while its row still
+claims it has none, and so does a field added to `PERSISTED_FIELDS` with no row
+at all. The per-field justification that used to live in the header of
+`src/shared/stateSchema.js` shipped a false claim in three consecutive changes,
+each caught only by a reviewer re-deriving thirty fields by hand.

 The `allowedSites` case is why the entry check is not optional. A stored
 `{"0x…": "notalist"}` is a well-formed object holding a malformed entry: it
@@ -1149,13 +1195,17 @@ view would leave a wallet one click from deletion.
    - Send / Receive quick-action buttons, both acting on the active address
    - ETH/USD price display
    - Wallet list: each wallet shows its name (tap to rename inline) and a "+"
-      button for HD and xprv wallets, then one block per address with "Address
-      N" (bold when active), the ENS name if resolved, the full address, an
-      `[info]` button, an `[x]` button (only on HD and xprv wallets holding more
-      than one address), the address USD total, and a balance line for ETH and
-      for each token shown for that address
+      button for HD and xprv wallets, then one block per address. The block
+      opens with a row carrying the colour dot, "Address N" (bold when active),
+      an `[info]` button and an `[x]` button (only on HD and xprv wallets
+      holding more than one address); the ENS name, if resolved, is below it;
+      then the full address on a row of its own, followed by the address USD
+      total and a balance line for ETH and for each token shown for that address
    - "Recent Transactions": up to 25 transactions merged across every address
-      of every wallet, deduplicated by hash and filtered
+      of every wallet, deduplicated by hash and filtered. Each row is three
+      lines: age and direction, then the counterparty's colour dot (with our own
+      name for it, where it is one of our addresses) and the amount, then the
+      counterparty's full address on a row of its own
    - "Add additional wallet..." link at bottom
 - **Transitions**:
    - Tap address row → sets the active address and broadcasts
@@ -45,6 +45,143 @@ but the review is broader than any of them.

 # Completed Steps

+- 2026-09-21: The network fee a transaction can commit is bounded by the product
+  of the gas limit and the fee per gas, not by each field alone, and the
+  wallet's own send is bounded the same way
+  ([#399](https://git.eeqj.de/sneak/AutistMask/issues/399)). The two per-field
+  ceilings in `src/shared/approvalVerify.js` were checked independently, so a
+  gas limit and a fee that were each under their own ceiling still multiplied to
+  thousands of ETH — a fee a gas-consuming contract really collects — while the
+  comment claimed the ceiling caught exactly that. `assertWithinCeilings` now
+  also refuses a transaction whose gas limit times its fee per gas
+  (`maxFeePerGas` for a type-2 transaction, `gasPrice` for a legacy or type-1
+  one) exceeds `MAX_TOTAL_FEE`, a new constant of 1 ETH beside the existing
+  ceilings, so both callers — where the dApp transaction is populated and where
+  the signed artifact is verified — reject it with a full sentence naming the
+  fee and the limit. The wallet's own send in `src/popup/views/confirmTx.js`
+  pinned no fee fields, so ethers filled them from whatever the configured node
+  answered with nothing bounding them; it now populates the transaction and runs
+  the same check before signing, showing the same error in the confirmation
+  screen's reserved errors box so nothing on screen moves. Deliberately out of
+  scope: comparing a supplied fee against the node's own suggested fee, which
+  the absolute bound already makes unnecessary for the balance-draining case. 1
+  ETH is a plain constant, one line to change; the owner may prefer another
+  figure.
+- 2026-09-21: The test recovery phrase no longer survives in a release bundle,
+  and the committed-key guard matches by content
+  ([#351](https://git.eeqj.de/sneak/AutistMask/issues/351)). `DEBUG_MNEMONIC` in
+  `src/shared/constants.js` is now behind the `__BUILD_DEBUG__` define, so a
+  release build folds the phrase to `null` and no emitted bundle carries it; it
+  used to survive as dead text because `module.exports` keeps the const alive.
+  `script/verify-build` now fails a release build if the phrase appears in any
+  emitted file, so the fold cannot silently regress. `tests/extensionId.test.js`
+  scans the content of every tracked file for a PEM private-key header instead
+  of matching filename extensions alone.
+- 2026-09-21: A transaction response is honoured only for a transaction
+  approval, and the three remaining approval-settlement paths are pinned
+  ([#262](https://git.eeqj.de/sneak/AutistMask/issues/262)). The liveness fix
+  the issue asks for — settle `4001` on release when the window it would be
+  retried in is gone — already landed with
+  [#271](https://git.eeqj.de/sneak/AutistMask/issues/271); this closes the rest.
+  `AUTISTMASK_TX_RESPONSE` now refuses any approval that is not a transaction
+  approval, so a reject no longer retires a sign or connection approval and a
+  signed artifact never runs the broadcast path against one, which before only
+  failed closed by throwing deeper in. Tests pin the site-connection port's
+  approve, reject and disconnect paths against a transaction approval
+  broadcasting behind them: each is declined and the dApp still receives its
+  broadcast result.
+- 2026-09-21: `docs/RELEASE.md`, linked from `README.md`, states the release
+  procedure as a numbered list a newcomer can follow: confirm `main` is green in
+  CI, confirm the one version in the three files matches the intended tag,
+  `make package` from a clean checkout, verify `SHA256SUMS`, tag `vX.Y.Z`, then
+  distribute per browser. Each step names who performs it (owner-only steps
+  marked) and the check that it worked. The distribution step is written as
+  pending the owner's choice on
+  [#386](https://git.eeqj.de/sneak/AutistMask/issues/386), with the Firefox and
+  Chrome options named but none settled. Docs only
+  ([#387](https://git.eeqj.de/sneak/AutistMask/issues/387)).
+
+- 2026-09-21: Adding a second wallet no longer accepts a different password with
+  nothing saying it is a separate one
+  ([#374](https://git.eeqj.de/sneak/AutistMask/issues/374)). Each wallet has its
+  own encrypted secret, so per-wallet passwords are by design; the add-wallet
+  screen said only "Choose a password". A note now appears on that screen when
+  the profile already holds a wallet, stating that each wallet has its own
+  password and this one need not match any already in use. It is shown only
+  then, since the first wallet has no other password to differ from, and it
+  stays consistent with the no-reset reality of
+  [#312](https://git.eeqj.de/sneak/AutistMask/issues/312) by promising no
+  recovery or reset.
+
+- 2026-09-21: The dApp approval and transaction-status screens resolve a token's
+  symbol from the bundled list, then the tokens the user tracks, then the block
+  explorer's report — the same sources and precedence the amount line already
+  used for the token's scale
+  ([#323](https://git.eeqj.de/sneak/AutistMask/issues/323), folding in
+  [#354](https://git.eeqj.de/sneak/AutistMask/issues/354)). A token the user
+  added by hand, or holds a balance of, is now named rather than labelled
+  `Unknown token`, and a non-bundled ERC-20 is no longer carried onto the wait
+  screen as `ETH`. A tracked or explorer-reported name stays subject to the
+  spoof rule, so resolving a symbol is not a new way to wear a known ticker.
+- 2026-09-21: The debug/testnet banner no longer shows the internal view id to
+  the user in a release build
+  ([#375](https://git.eeqj.de/sneak/AutistMask/issues/375)). The banner appended
+  the active view's id (e.g. `[TESTNET] (approve-tx)`), which is developer
+  vocabulary sitting directly above the approval screen's carefully worded
+  authorization text. The suffix is now gated on the compile-time `DEBUG`
+  constant rather than `isDebug()`, so it survives only in a debug build; a
+  testnet or the runtime debug toggle still raises the banner but without the
+  view id.
+
+- 2026-09-21: The Confirm Delete button on the delete-wallet screen no longer
+  stays dead after a successful delete
+  ([#335](https://git.eeqj.de/sneak/AutistMask/issues/335)). The password route
+  disabled the button before the decrypt and never re-enabled it, so a second
+  delete in the same popup session needed a reopen; the lost-password route
+  re-enabled its own button in its leave hook, so the two screens behaved
+  differently. Both now reset through the shared `finishDelete()`, the one path
+  both routes take, so they behave the same and the button is live for the next
+  delete.
+
+- 2026-09-21: The EIP-6963 provider UUID is generated fresh on each page load
+  and never persisted ([#398](https://git.eeqj.de/sneak/AutistMask/issues/398)).
+  It was created once and stored, then announced verbatim to every page on every
+  load and across restarts, so any site — connected or not — could read it as a
+  stable cross-site, cross-session identifier for the install, contradicting the
+  "no tracking" promise. inpage.js now announces a per-load
+  `crypto.randomUUID()` and the `eip6963Uuid` storage key and the
+  `AUTISTMASK_PROVIDER_UUID` content-script message are gone. That key was a
+  standalone storage entry, never part of the versioned `autistmask` profile, so
+  the state schema is untouched and no existing profile is affected.
+
+- 2026-08-30: An address no longer wraps, or is shortened to fit, in any of the
+  common views ([#380](https://git.eeqj.de/sneak/AutistMask/issues/380)). The
+  wallet list was the reported case: the address shared one row with the
+  `[info]` and `[x]` controls and folded onto a second line, which turns one
+  42-character string the user is meant to compare into two shorter ones — the
+  shape an address-poisoning attack wants. The fix is layout, not CSS: every
+  address in the popup now sits alone on a full-width row, with the colour dot,
+  the wallet title, the ENS name and the explorer link moved onto a strip above
+  it, and the transaction rows carry the counterparty's whole address instead of
+  a `truncateMiddle()`d one squeezed in beside the amount. `truncateMiddle()`
+  keeps its 10-character cap and its 32-character floor moved into
+  `renderAddressHtml()`, so the guarantee outlives having no callers. The e2e
+  suite measures every rendered address in a real Chromium — whole, one line
+  box, inside its row and inside the popup — across Home, the address, token,
+  receive, send and transaction detail screens, the confirmation screen and the
+  dApp transaction prompt.
+- 2026-08-23: Both manifests declare toolbar icons, and real PNGs at
+  16/32/48/128 ship inside both archives
+  ([#371](https://git.eeqj.de/sneak/AutistMask/issues/371)). Neither manifest
+  had an `icons` block, so both browsers drew a generic puzzle piece — the first
+  thing the owner sees on every launch, and how a user tells a real extension
+  from a look-alike. The sizes `build.js` copies into each browser directory are
+  read out of the manifest that ships next to them rather than from a second
+  list, so a declared size `icons/` does not hold fails `make build`;
+  `script/lib/package.js` already resolves `.png` references, so an icon that
+  reached a manifest but not the archive fails packaging. The artwork is
+  original: a flat dark-navy rounded field with a teal triangular "A", drawn
+  from geometry and rasterised into PNG, nothing traced or downloaded.
 - 2026-08-23: A persisted container whose ENTRIES were dereferenced unchecked no
  longer reaches a `.map()` or a `.toLowerCase()`
  ([#362](https://git.eeqj.de/sneak/AutistMask/issues/362)). `allowedSites` was
@@ -67,8 +204,21 @@ but the review is broader than any of them.
  justification in the header of `src/shared/stateSchema.js` — which had shipped
  a false claim in three consecutive changes — is replaced by
  `tests/persistedFieldContract.test.js`, one row per persisted field, each
-  proven by driving the real code with hostile values; a field with no row, or a
-  row whose claim is false, now fails `make check`.
+  proven by driving the real code with hostile values — and, for a field whose
+  only defence is that nothing dereferences it, by booting the real popup entry
+  point over that value onto every view the popup can reopen onto, since that is
+  the path this whole class of defect lives on. Each such field is driven at
+  both polarities — a value nothing writes is wrong-typed and so truthy, so a
+  falsy slot is driven too, or the field is proven unable to be falsy after the
+  floor. The claim is narrow and stated as such: no structural dereference on
+  the code paths a wholly-corrupted profile takes, which is not every path a
+  stored record takes — a pairing of values the four slots do not produce, a
+  view only forward navigation opens, anything behind a click, and everything a
+  healthy profile reaches are all undriven. Within that boundary the verdict is
+  unconditional, including a dereference that takes two corrupted fields at
+  once, since the assertion is on the combined boot and the per-field re-boot
+  can only decorate the message. A field with no row and a field that gains a
+  floor while its row still claims it has none also fail `make check`.
 - 2026-08-23: A swap amount and the token it is counted in now always come from
  the same hop, on both sides of the approval screen
  ([#359](https://git.eeqj.de/sneak/AutistMask/issues/359) and
@@ -146,6 +296,46 @@ but the review is broader than any of them.
  `src/shared/restorableViews.js`, since `persistedState.js` requires it and
  that module is in the background bundle.

+- 2026-08-23: An explorer that reports no `decimals` for a token no longer has a
+  scale invented for it before storage
+  ([#349](https://git.eeqj.de/sneak/AutistMask/issues/349)).
+  `fetchTokenBalances()` did `parseInt(item.token.decimals || "18", 10)` on the
+  way in, so a token whose `decimals()` reverts was written to
+  `tokenBalances[].decimals` as a fabricated `18` that no reader could tell from
+  a real one. That is upstream of the resolve-or-refuse rule
+  ([#306](https://git.eeqj.de/sneak/AutistMask/issues/306),
+  [#340](https://git.eeqj.de/sneak/AutistMask/issues/340)): both approval paths
+  read this stored value as an authoritative source, so the guess walked past
+  refusals that were intact and simply never fired. The stored value is now the
+  explorer's own answer or `null`, and both the ERC-20 amount line and the swap
+  lines reach `unknownDecimalsAmount()` on it. The history list's token
+  transfers carried the same `|| "18"` and now state base units with the scale
+  unknown rather than a quantity. A holding whose scale nothing knows carries
+  `balance: null` — unknown, not zero — and the balance list, the USD total, the
+  Send screen and the confirmation screen each say so instead of printing
+  `0.0000` for money that is really there. The uint8 check is one shared
+  `toDecimals()` rather than three copies, and it answers `0` for a real scale
+  of zero: `|| "18"` collapsed that to eighteen, the trap of
+  [#246](https://git.eeqj.de/sneak/AutistMask/issues/246). Existing installs
+  hold `18`s that cannot be told apart retroactively; they display exactly as
+  they do today until the next balance refresh, which rewrites `tokenBalances`
+  wholesale and needs no user action. No `|| 18` or `?? 18` fallback remains
+  anywhere in `src/`; the literal `18`s that do remain are real data, not
+  defaults — 432 per-token `decimals: 18` entries in the bundled
+  `src/shared/tokenList.js`, and, outside that file, only native ETH's
+  protocol-defined scale in `src/shared/uniswap.js` and the fixed-point
+  comparison scale in `src/shared/txValidation.js`. `tokenBalances[].decimals`
+  is the explorer's answer alone and not the scale a screen renders at, so the
+  Send screen resolves through `resolveTokenDecimals()` like every other
+  consumer: reading the stored field raw carried a `null` into `estimateGas()`
+  for a bundled token such as WETH, which reported an unestimable network fee
+  and left Send disabled behind a message no retry could clear. Send resolves
+  with `wallets`, which adds the cross-address disagreement check the balance
+  list does not make, so the two can differ; where they do, the stored quantity
+  was computed at a scale Send has refused, and it is withdrawn with it. An
+  unknown scale is an unknown balance, and the user is told that rather than
+  that the fee could not be estimated.
+
 - 2026-08-23: The background no longer reads or writes the shared `state`
  singleton ([#324](https://git.eeqj.de/sneak/AutistMask/issues/324)), which
  also closes the cold-worker wrong-chain send
@@ -51,6 +51,17 @@ const RECEIPT_ENV = "AUTISTMASK_BUILD_RECEIPT";
 // rather than writing a receipt that cannot be checked.
 const SAFE_EMITTED_PATH = /^dist\/[A-Za-z0-9._][A-Za-z0-9._/-]*$/;

+// Where each browser directory's manifest comes from, and — through its
+// "icons" — which image files ship inside that directory.
+const MANIFEST_SOURCES = new Map([
+    [DIST_CHROME, path.join(__dirname, "manifest", "chrome.json")],
+    [DIST_FIREFOX, path.join(__dirname, "manifest", "firefox.json")],
+]);
+
+// What an "icons" entry may name: a plain file under icons/, so a manifest
+// value is never joined into a path that leaves the repo.
+const ICON_REF_RE = /^icons\/[A-Za-z0-9._-]+\.png$/;
+
 function ensureDir(dir) {
    fs.mkdirSync(dir, { recursive: true });
 }
@@ -257,6 +268,42 @@ function copyEmitted(src, dest) {
    recordEmitted(dest);
 }

+// Copy the icons one browser directory ships. The sizes come from the manifest
+// that will sit next to them, not from a second list here: a size the manifest
+// declares and icons/ does not hold fails the build, rather than shipping a
+// manifest whose reference resolves to nothing. Relative to the browser
+// directory, so nothing points up and out of it the way dist/styles.css does.
+function copyIcons(distDir) {
+    const manifestPath = MANIFEST_SOURCES.get(distDir);
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    const refs = Object.values(manifest.icons || {});
+    if (refs.length === 0) {
+        throw new Error(
+            `${repoRelative(manifestPath)} declares no icons, so the browser ` +
+                `renders a generic placeholder for this extension`,
+        );
+    }
+    for (const ref of refs) {
+        if (!ICON_REF_RE.test(ref)) {
+            throw new Error(
+                `${repoRelative(manifestPath)} declares icon ` +
+                    `${JSON.stringify(ref)}, which is not a plain file under ` +
+                    `icons/`,
+            );
+        }
+        const src = path.join(__dirname, ref);
+        if (!fs.existsSync(src)) {
+            throw new Error(
+                `${repoRelative(manifestPath)} declares ${ref}, which is not ` +
+                    `in this tree`,
+            );
+        }
+        const dest = path.join(distDir, ref);
+        ensureDir(path.dirname(dest));
+        copyEmitted(src, dest);
+    }
+}
+
 function sha256File(absPath) {
    return crypto
        .createHash("sha256")
@@ -524,6 +571,8 @@ async function build() {
            tailwindOutput,
            path.join(distDir, "src", "popup", "styles.css"),
        );
+
+        copyIcons(distDir);
    }

    // copy manifests
@@ -0,0 +1,87 @@
+# Releasing AutistMask
+
+This is the procedure that turns a green `main` into a tagged, packaged release.
+It gathers into one place what is otherwise spread across the `Makefile` and
+three `README.md` sections, so the person cutting a release does not have to
+reconstruct the order from them.
+
+There is one version, declared in three files (`package.json`,
+`manifest/chrome.json`, `manifest/firefox.json`), and `make package` builds and
+packages but publishes nothing. `make build` and `make package` can be run by
+anyone; tagging, signing, packing a CRX and any upload need credentials only the
+owner ([@sneak](https://sneak.berlin)) holds and are marked **owner-only**
+below. Releases are tagged from `main` (see the Workflow section of `TODO.md`),
+so the "release commit" throughout is the `main` commit the milestone PR merged.
+
+## Procedure
+
+1. **Confirm `main` is green in CI.** The `check` workflow
+   (`.gitea/workflows/check.yml`) runs `script/cibuild`, i.e. `docker build .`,
+   and the `Dockerfile` runs `make check` as a build step, so a green `check`
+   run is a green `make check`. Find the run for the exact release commit on the
+   tracker's Actions view. _Check:_ that commit's `check` run succeeded; running
+   `make check` on a clean checkout of the commit reproduces it and exits 0.
+
+2. **Confirm the version matches the intended tag.** `package.json`,
+   `manifest/chrome.json` and `manifest/firefox.json` must all declare the same
+   `X.Y.Z`. `make build` fails when they disagree, but nothing checks that they
+   equal the tag you mean to create — that is this manual step. _Check:_ all
+   three files read the same `X.Y.Z`, and it is the version you intend to tag
+   `vX.Y.Z`.
+
+3. **Build and package from a clean checkout of that commit.** From a fresh
+   clone, or a working tree with no local modifications (`git status` clean),
+   checked out at the release commit: run `make setup`, then `make package`.
+   `make package` runs `make build` first, so the archives can only be made from
+   a `dist/` verified against that build's own receipt as a release (not debug)
+   build. It writes three files into `release/`:
+   `autistmask-chrome-<version>.zip`, `autistmask-firefox-<version>.xpi`, and
+   `SHA256SUMS`. _Check:_ those three files exist and `<version>` in the archive
+   names is the version confirmed in step 2. The Firefox `.xpi` is **unsigned**
+   (see step 6 and "Installing on Firefox" in `README.md`).
+
+4. **Verify `SHA256SUMS`.** The archives are deterministic — sorted entries,
+   fixed timestamps, fixed compression — so a second `make package` from another
+   clean checkout of the same commit produces byte-identical files. Verify the
+   recorded digests against the files with `sha256sum -c SHA256SUMS`, run from
+   `release/`. To confirm reproducibility, run `make package` again on a
+   separate clean checkout and compare the digests. _Check:_ `sha256sum -c`
+   reports `OK` for every file, and an independent build's digests match.
+
+5. **Tag the release commit.** _(owner-only)_ Create an annotated tag `vX.Y.Z`
+   on the release commit and push it: `git tag -a vX.Y.Z` (with a message), then
+   `git push origin vX.Y.Z`. _Check:_ `git tag` lists `vX.Y.Z`, and
+   `git rev-parse vX.Y.Z^{commit}` resolves to the release commit.
+
+6. **Distribute per browser.** _(owner-only; pending the owner's choice on
+   https://git.eeqj.de/sneak/AutistMask/issues/386)_ How 1.0.0 is distributed on
+   each browser is not yet decided; it is the open question on that issue, and
+   the concrete steps cannot be written until the owner records a choice there.
+   These steps need credentials only the owner holds. The options under
+   consideration are:
+    - **Firefox** — the packaged `.xpi` is unsigned, and release Firefox and ESR
+      refuse an unsigned add-on:
+        - (a) AMO self-distribution signing (unlisted): submit the `.xpi` to AMO
+          with the owner's credentials; AMO returns a signed `.xpi` installable
+          on every Firefox, with nothing listed publicly.
+        - (b) AMO listed: as (a), plus a public AMO listing and review.
+        - (c) Ship the unsigned `.xpi` and state that Firefox support means
+          Developer Edition, Nightly, or an Unbranded build with
+          `xpinstall.signatures.required` set to `false`.
+    - **Chrome** — the repo packs no CRX and publishes nothing; the extension id
+      is fixed by the `key` in `manifest/chrome.json`:
+        - (a) Chrome Web Store (unlisted): upload the `.zip` with the owner's
+          developer account; the store delivers installs and updates.
+        - (b) Self-hosted CRX signed with the private key the owner holds
+          (`chrome --pack-extension=dist/chrome --pack-extension-key=<path to the .pem>`),
+          installable only via enterprise policy on Windows and macOS, so
+          realistically Linux-only.
+        - (c) "Load unpacked" from `dist/chrome/` only, as today.
+
+    Once the owner decides, the chosen steps — including which credentials they
+    need and who holds them — are written into this section and `README.md`'s
+    installation sections are updated to match, which is part of the definition
+    of done of https://git.eeqj.de/sneak/AutistMask/issues/386. _Check:_ for a
+    store or AMO route, the artifact installs from the store or AMO on a clean
+    browser profile; for the CRX or unpacked route, the documented load succeeds
+    and Chrome reports the extension id `gipbhkogfopeahplcjhipkgpcimdpkip`.
@@ -9,6 +9,12 @@
    "content_security_policy": {
        "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'"
    },
+    "icons": {
+        "16": "icons/icon16.png",
+        "32": "icons/icon32.png",
+        "48": "icons/icon48.png",
+        "128": "icons/icon128.png"
+    },
    "action": {
        "default_popup": "src/popup/index.html"
    },
@@ -5,6 +5,12 @@
    "description": "Minimal Ethereum wallet for Firefox",
    "permissions": ["storage", "activeTab", "alarms", "<all_urls>"],
    "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'",
+    "icons": {
+        "16": "icons/icon16.png",
+        "32": "icons/icon32.png",
+        "48": "icons/icon48.png",
+        "128": "icons/icon128.png"
+    },
    "browser_action": {
        "default_popup": "src/popup/index.html"
    },
@@ -37,6 +37,10 @@ DISCARD_DIST="$ROOT/script/discard-dist-on-failure"
 MARKER_ON="autistmask-build-debug=on"
 MARKER_OFF="autistmask-build-debug=off"

+# The same test recovery phrase verify-build searches release bundles for. Held
+# here too, the way the markers above are, so a case can plant it in a bundle.
+TEST_MNEMONIC="cube evolve unfold result inch risk jealous skill hotel bulb night wreck"
+
 RECEIPT_HEADER="autistmask-build-receipt v1"

 NEWLINE='
@@ -516,6 +520,24 @@ c_debug_build() {
    write_receipt
 }

+# A release bundle that still carries the test recovery phrase — the regression
+# verify-build guards against, and the reason DEBUG_MNEMONIC is behind the
+# __BUILD_DEBUG__ define in src/shared/constants.js. The receipt is regenerated
+# so the phrase is caught as bundle content, not incidentally as a stale digest.
+c_release_bundle_with_mnemonic() {
+    printf '/* %s */\n' "$TEST_MNEMONIC" >>dist/chrome/src/popup/index.js
+    write_receipt
+}
+
+# The same phrase in a debug build is expected: make build-debug ships it on
+# purpose, so the phrase check must stay quiet under --expect debug.
+c_debug_bundle_with_mnemonic() {
+    write_bundle dist/chrome/src/popup/index.js "$MARKER_ON"
+    write_bundle dist/firefox/src/popup/index.js "$MARKER_ON"
+    printf '/* %s */\n' "$TEST_MNEMONIC" >>dist/chrome/src/popup/index.js
+    write_receipt
+}
+
 c_no_dist() { rm -rf dist; }

 # --- dist discard -----------------------------------------------------------
@@ -753,6 +775,13 @@ run_cases() {
    check_case "debug bundles under --expect debug pass" \
        no debug 0 "2 bundle(s) $MARKER_ON" c_debug_build

+    check_case "release bundle carrying the test recovery phrase fails" \
+        no release 1 \
+        "carries the BIP-39 test recovery phrase" c_release_bundle_with_mnemonic
+
+    check_case "debug bundle carrying the test recovery phrase passes" \
+        no debug 0 "2 bundle(s) $MARKER_ON" c_debug_bundle_with_mnemonic
+
    check_case "no --expect argument" \
        no no-expect 1 "no --expect argument." c_control

@@ -13,6 +13,12 @@
 # fallback branch; the property only exists in the emitted output, so it has to
 # be asserted against the emitted output.
 #
+# The DEBUG half also checks the phrase directly: a release build must not carry
+# the test recovery phrase in any emitted file. The phrase is behind the
+# __BUILD_DEBUG__ define in src/shared/constants.js and folds away in a release
+# build, but the marker only proves DEBUG compiled off, not that the fold
+# removed the string; the phrase grep is the assertion that it did.
+#
 # 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
@@ -67,6 +73,15 @@ TAB='	'
 MARKER_ON="autistmask-build-debug=on"
 MARKER_OFF="autistmask-build-debug=off"

+# The 12-word BIP-39 test recovery phrase from src/shared/constants.js. It is
+# behind the __BUILD_DEBUG__ define there, so a release build folds it out of
+# every bundle; this is the assertion that it stayed out. The phrase is a
+# publicly committed test value rather than a secret, but a BIP-39 phrase in a
+# distributed wallet artifact is exactly the string a scanner or auditor has to
+# stop and reason about, so a release build must not ship it. A debug build
+# ships it on purpose, so this is checked only when release is expected.
+TEST_MNEMONIC="cube evolve unfold result inch risk jealous skill hotel bulb night wreck"
+
 RECEIPT_HEADER="autistmask-build-receipt v1"

 # Set by the arguments.
@@ -283,6 +298,18 @@ check_entry() {
    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."

+    # No emitted file of a release build may carry the test recovery phrase.
+    # Checked on every file, not only the audited bundles, so a copy that
+    # reached some other emitted file fails here too. A debug build ships the
+    # phrase deliberately, so this runs only when release was expected.
+    if [ "$EXPECT" = "$MARKER_OFF" ] && has_marker "$TEST_MNEMONIC" "$ENTRY_PATH"; then
+        fail "$ENTRY_PATH carries the BIP-39 test recovery phrase, which a
+    release build must fold out. The __BUILD_DEBUG__ define in build.js is what
+    drops it from src/shared/constants.js; check that DEBUG_MNEMONIC is still
+    behind that flag. A recovery phrase in a distributed bundle is exactly the
+    string an auditor or scanner has to stop on, so this is a hard failure."
+    fi
+
    if [ "$ENTRY_FLAG" = A ]; then
        read_marker "$ENTRY_PATH"
        [ "$MARKER" = "$EXPECT" ] ||
@@ -1344,6 +1344,15 @@ runtime.onMessage.addListener((msg, sender, sendResponse) => {
        const approval = pendingApprovals[msg.id];
        if (!approval) return false;

+        // This message signs and broadcasts a transaction, so it is honoured
+        // only for a transaction approval. A sign or connection approval
+        // carries no approvedTx, and reaching the broadcast path with one used
+        // to fail closed by throwing deeper in; refusing here keeps a future
+        // refactor from turning that incidental throw into a live path, and
+        // keeps a reject on this message from retiring an approval of another
+        // kind.
+        if (approval.type !== "tx") return false;
+
        // A reject arriving while an attempt holds the approval is refused,
        // not honoured: the attempt is on its way to broadcasting the
        // transaction, and resolving 4001 here would tell the page the request
@@ -5,8 +5,6 @@ const {
    hasBrowserNamespace,
    runtimeApi,
    sendMessage,
-    storageGet,
-    storageSet,
 } = require("../shared/browserApi");

 // In Chrome (MV3), inpage.js runs as a MAIN-world content script declared
@@ -21,30 +19,6 @@ if (hasBrowserNamespace()) {
    (document.head || document.documentElement).appendChild(script);
 }

-// Send the persisted EIP-6963 provider UUID to the inpage script.
-// Generated once at install time and stored in extension storage.
-(async function sendProviderUuid() {
-    let uuid = null;
-    try {
-        const items = await storageGet("eip6963Uuid");
-        uuid = items?.eip6963Uuid;
-        if (!uuid) {
-            uuid = crypto.randomUUID();
-            await storageSet({ eip6963Uuid: uuid });
-        }
-    } catch {
-        // Storage was unavailable or refused the write. The announcement
-        // still has to go out — a provider that never announces is invisible
-        // to every EIP-6963 dApp — so it goes under a fresh uuid that this
-        // page load will not outlive.
-        if (!uuid) uuid = crypto.randomUUID();
-    }
-    window.postMessage(
-        { type: "AUTISTMASK_PROVIDER_UUID", uuid },
-        location.origin,
-    );
-})();
-
 // Relay requests from the page to the background script
 window.addEventListener("message", (event) => {
    if (event.source !== window) return;
@@ -204,7 +204,14 @@
                "</svg>",
        );

-    let providerUuid = crypto.randomUUID(); // fallback until real UUID arrives
+    // EIP-6963 wants a fresh UUIDv4 per page load — it identifies one
+    // announcement, so a provider can be told apart from another instance of
+    // itself in the same page. It is generated here and never stored:
+    // announcing one persisted value to every site, on every load and across
+    // restarts, turned it into a stable cross-site, cross-session tracking
+    // identifier any page could read
+    // (https://git.eeqj.de/sneak/AutistMask/issues/398).
+    const providerUuid = crypto.randomUUID();

    function buildProviderInfo() {
        return {
@@ -226,16 +233,6 @@
        );
    }

-    // Listen for the persisted UUID from the content script
-    function onProviderUuid(event) {
-        if (event.source !== window) return;
-        if (event.data?.type !== "AUTISTMASK_PROVIDER_UUID") return;
-        window.removeEventListener("message", onProviderUuid);
-        providerUuid = event.data.uuid;
-        announceProvider();
-    }
-    window.addEventListener("message", onProviderUuid);
-
    window.addEventListener("eip6963:requestProvider", announceProvider);
    announceProvider();

@@ -152,6 +152,21 @@

                <!-- Shared password fields -->
                <div class="mb-2" id="add-wallet-password-section">
+                    <!-- Shown only when the profile already holds a wallet:
+                         each wallet has its own password (its own
+                         encryptedSecret), so a second wallet does not reuse
+                         the first one's. addWallet.js toggles this on screen
+                         entry from state.wallets.length, so it is constant
+                         while the screen is up and moves nothing. -->
+                    <p
+                        class="text-xs mb-2 border border-border border-dashed p-2 hidden"
+                        id="add-wallet-separate-password-note"
+                    >
+                        You already have a wallet. Each wallet has its own
+                        password: the one you choose here is only for this new
+                        wallet, and it need not match any password you already
+                        use.
+                    </p>
                    <label class="block mb-1">Choose a password</label>
                    <!-- The hint is swapped in place when the import tab
                         changes, and it sits directly above the password
@@ -213,10 +228,7 @@
                </div>

                <!-- active address display -->
-                <div
-                    id="active-address-display"
-                    class="text-xs break-all mb-3"
-                ></div>
+                <div id="active-address-display" class="text-xs mb-3"></div>

                <!-- quick actions for active address -->
                <div class="flex gap-2 mb-2">
@@ -292,7 +304,7 @@
                    class="font-bold mb-1 hidden flex items-center"
                ></div>
                <div
-                    class="text-xs mb-1 cursor-pointer break-all"
+                    class="text-xs mb-1 cursor-pointer"
                    title="Click to copy"
                    id="address-line"
                >
@@ -380,14 +392,14 @@
                ></div>
                <h2 class="font-bold mb-1">Export Private Key</h2>
                <p class="text-xs mb-1" id="export-privkey-title"></p>
-                <p class="text-xs mb-3">
+                <div class="text-xs mb-3">
                    <span id="export-privkey-dot"></span>
                    <span
                        id="export-privkey-address"
                        class="cursor-pointer"
                        title="Click to copy"
                    ></span>
-                </p>
+                </div>
                <p class="text-xs mb-3 text-muted">
                    Warning: anyone with this private key can access and
                    transfer all funds from this address. Never share it.
@@ -440,7 +452,7 @@
                </div>

                <div
-                    class="text-xs mb-1 cursor-pointer break-all"
+                    class="text-xs mb-1 cursor-pointer"
                    title="Click to copy"
                    id="address-token-line"
                >
@@ -573,19 +585,16 @@
                <!-- ERC-20 token contract (hidden for ETH) -->
                <div id="confirm-token-section" class="mb-3 hidden">
                    <div class="text-xs text-muted mb-1">Token contract</div>
-                    <div
-                        id="confirm-token-contract"
-                        class="text-xs break-all"
-                    ></div>
+                    <div id="confirm-token-contract" class="text-xs"></div>
                </div>

                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">From</div>
-                    <div id="confirm-from" class="text-xs break-all"></div>
+                    <div id="confirm-from" class="text-xs"></div>
                </div>
                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">To</div>
-                    <div id="confirm-to" class="text-xs break-all"></div>
+                    <div id="confirm-to" class="text-xs"></div>
                    <div
                        id="confirm-to-ens"
                        class="text-xs text-muted hidden"
@@ -728,7 +737,7 @@
                </div>
                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">To</div>
-                    <div id="wait-tx-to" class="text-xs break-all"></div>
+                    <div id="wait-tx-to" class="text-xs"></div>
                </div>
                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">Transaction hash</div>
@@ -747,7 +756,7 @@
                </div>
                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">To</div>
-                    <div id="success-tx-to" class="text-xs break-all"></div>
+                    <div id="success-tx-to" class="text-xs"></div>
                </div>
                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">Block</div>
@@ -774,7 +783,7 @@
                </div>
                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">To</div>
-                    <div id="error-tx-to" class="text-xs break-all"></div>
+                    <div id="error-tx-to" class="text-xs"></div>
                </div>
                <div class="mb-3">
                    <div
@@ -811,9 +820,9 @@
                    <canvas id="receive-qr"></canvas>
                </div>
                <div
-                    class="border border-border p-2 break-all mb-3 text-xs cursor-pointer"
+                    class="border border-border p-2 mb-3 text-xs cursor-pointer"
                >
-                    <span id="receive-address-block" class="select-all"></span>
+                    <div id="receive-address-block" class="select-all"></div>
                    <span id="receive-etherscan-link"></span>
                </div>
                <button
@@ -1239,7 +1248,7 @@
                </p>
                <div
                    id="delete-address-value"
-                    class="text-xs mb-2 break-all min-h-[1rem]"
+                    class="text-xs mb-2 min-h-[1rem]"
                ></div>
                <div
                    class="text-xs mb-2 border border-border border-dashed p-2"
@@ -1429,14 +1438,11 @@
                    </div>
                    <div class="mb-2">
                        <div class="text-xs text-muted mb-1">From</div>
-                        <div
-                            id="tx-detail-from"
-                            class="text-xs break-all"
-                        ></div>
+                        <div id="tx-detail-from" class="text-xs"></div>
                    </div>
                    <div class="mb-2">
                        <div class="text-xs text-muted mb-1">To</div>
-                        <div id="tx-detail-to" class="text-xs break-all"></div>
+                        <div id="tx-detail-to" class="text-xs"></div>
                    </div>
                </div>

@@ -1473,7 +1479,7 @@
                        </div>
                        <div
                            id="tx-detail-token-contract"
-                            class="text-xs break-all"
+                            class="text-xs"
                        ></div>
                    </div>
                </div>
@@ -1567,11 +1573,11 @@

                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">From</div>
-                    <div id="approve-tx-from" class="text-xs break-all"></div>
+                    <div id="approve-tx-from" class="text-xs"></div>
                </div>
                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">Contract</div>
-                    <div id="approve-tx-to" class="text-xs break-all"></div>
+                    <div id="approve-tx-to" class="text-xs"></div>
                </div>
                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">Value</div>
@@ -1673,7 +1679,7 @@

                <div class="mb-3">
                    <div class="text-xs text-muted mb-1">From</div>
-                    <div id="approve-sign-from" class="text-xs break-all"></div>
+                    <div id="approve-sign-from" class="text-xs"></div>
                </div>

                <div class="mb-3">
@@ -44,3 +44,23 @@ body {
        background-color 225ms ease-out,
        color 225ms ease-out;
 }
+
+/* An address is one atomic string, so it gets a row of its own and never
+ * breaks across lines. A wrapped address reads as two shorter strings, and
+ * two shorter strings are exactly what an address-poisoning attack needs
+ * the user to compare instead of the whole thing. Every view that shows an
+ * address puts it in one of these, alone: the colour dot, the wallet title,
+ * the ENS name and the explorer link all live on their own line above, so
+ * nothing competes with the 42 characters for width.
+ *
+ * overflow-x is the escape hatch, not the mechanism. The row is wide enough
+ * for a full address at every nesting depth the popup uses; if that ever
+ * stops being true — a font with wider glyphs, a browser zoom — the row
+ * scrolls and the user can still reach the last character, rather than the
+ * tail being clipped away by #app's overflow-x-hidden with nothing to say
+ * it happened. tests/e2e asserts the scroll is never actually needed. */
+.am-address {
+    display: block;
+    white-space: nowrap;
+    overflow-x: auto;
+}
@@ -100,9 +100,24 @@ function clear() {
    $("add-wallet-phrase-warning").style.visibility = "hidden";
 }

+// Each wallet has its own password (its own encryptedSecret), so adding a
+// second wallet does not reuse the first one's. The note that says so is
+// only meaningful once a wallet exists — on the first wallet there is no
+// other password to be separate from — so it is shown only then. This is
+// decided on entry and stays put while the screen is up, so it does not
+// move the password fields the way a per-tab hint would.
+function updateSeparatePasswordNote() {
+    const hasExistingWallet = state.wallets.length > 0;
+    $("add-wallet-separate-password-note").classList.toggle(
+        "hidden",
+        !hasExistingWallet,
+    );
+}
+
 function show() {
    clear();
    switchMode("mnemonic");
+    updateSeparatePasswordNote();
    showView("add-wallet");
 }

@@ -7,7 +7,6 @@ const {
    addressTitle,
    escapeHtml,
    displaySymbol,
-    truncateMiddle,
    renderAddressHtml,
    attachCopyHandlers,
    goBack,
@@ -229,10 +228,12 @@ function renderTransactions(txs) {
        const amountStr = tx.value
            ? 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);
-        const addrStr = escapeHtml(displayAddr);
+        // The counterparty used to be squeezed in beside the amount and
+        // truncated to whatever was left over. It gets its own row now and
+        // is shown whole; the title or ENS name, where there is one, names
+        // it on the line above rather than replacing it.
+        const nameStr = escapeHtml(title || ensName || "");
+        const addrStr = escapeHtml(counterparty);
        const dot = addressDotHtml(counterparty);
        const err = tx.isError ? " (failed)" : "";
        const opacity = tx.isError ? " opacity:0.5;" : "";
@@ -240,7 +241,8 @@ function renderTransactions(txs) {
        const iso = escapeHtml(isoDate(tx.timestamp));
        html += `<div class="tx-row py-2 border-b border-border-light text-xs cursor-pointer hover:bg-hover" data-tx="${i}" style="${opacity}">`;
        html += `<div class="flex justify-between"><span class="text-muted" title="${iso}">${ago}</span><span>${dirLabel}${err}</span></div>`;
-        html += `<div class="flex justify-between"><span class="flex items-center">${dot}${addrStr}</span><span>${amountStr}</span></div>`;
+        html += `<div class="flex justify-between"><span class="flex items-center">${dot}${nameStr}</span><span>${amountStr}</span></div>`;
+        html += `<div class="am-address">${addrStr}</div>`;
        html += `</div>`;
        i++;
    }
@@ -10,8 +10,8 @@ const {
    addressTitle,
    escapeHtml,
    displaySymbol,
-    truncateMiddle,
    balanceLine,
+    unknownableAmount,
    renderAddressHtml,
    attachCopyHandlers,
    goBack,
@@ -118,7 +118,9 @@ function show() {
            addr.tokenBalances,
            state.trackedTokens,
        );
-        amount = tb ? parseFloat(tb.balance || "0") : 0;
+        // null when the scale is unknown: no quantity to show, and none to
+        // price. balanceLine() states that rather than printing 0.0000.
+        amount = tb ? unknownableAmount(tb.balance) : 0;
        price = getPrice(symbol);
    }

@@ -152,7 +154,7 @@ function show() {
    attachCopyHandlers($("address-token-line"));

    // USD total for this token only
-    const usdVal = price ? amount * price : null;
+    const usdVal = price && amount !== null ? amount * price : null;
    const usdStr = formatUsd(usdVal);
    $("address-token-usd-total").innerHTML = usdStr || "&nbsp;";

@@ -302,10 +304,12 @@ function renderTransactions(txs) {
        const amountStr = tx.value
            ? 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);
-        const addrStr = escapeHtml(displayAddr);
+        // The counterparty used to be squeezed in beside the amount and
+        // truncated to whatever was left over. It gets its own row now and
+        // is shown whole; the title or ENS name, where there is one, names
+        // it on the line above rather than replacing it.
+        const nameStr = escapeHtml(title || ensName || "");
+        const addrStr = escapeHtml(counterparty);
        const dot = addressDotHtml(counterparty);
        const err = tx.isError ? " (failed)" : "";
        const opacity = tx.isError ? " opacity:0.5;" : "";
@@ -313,7 +317,8 @@ function renderTransactions(txs) {
        const iso = escapeHtml(isoDate(tx.timestamp));
        html += `<div class="tx-row py-2 border-b border-border-light text-xs cursor-pointer hover:bg-hover" data-tx="${i}" style="${opacity}">`;
        html += `<div class="flex justify-between"><span class="text-muted" title="${iso}">${ago}</span><span>${dirLabel}${err}</span></div>`;
-        html += `<div class="flex justify-between"><span class="flex items-center">${dot}${addrStr}</span><span>${amountStr}</span></div>`;
+        html += `<div class="flex justify-between"><span class="flex items-center">${dot}${nameStr}</span><span>${amountStr}</span></div>`;
+        html += `<div class="am-address">${addrStr}</div>`;
        html += `</div>`;
        i++;
    }
@@ -20,9 +20,9 @@ const {
 } = require("ethers");
 const { getPrice, formatUsd } = require("../../shared/prices");
 const { ERC20_ABI } = require("../../shared/constants");
-const { TOKEN_BY_ADDRESS } = require("../../shared/tokenList");
 const {
    resolveTokenDecimals,
+    resolveTokenSymbol,
    unknownDecimalsAmount,
 } = require("../../shared/approvalAmount");
 // Four decimals, with the nonzero floor these screens hold: every amount this
@@ -63,9 +63,15 @@ function tokenAmountText(rawAmount, decimals, symbol) {
    };
 }

+// The symbol shown for a token line, resolved from the bundled list, the
+// tokens the user tracks, and the explorer's report — the same chain the
+// amount line's scale comes from. Null when no source names one, so the token
+// lines keep saying `Unknown token` for a token nothing knows.
 function tokenLabel(address) {
-    const t = TOKEN_BY_ADDRESS.get(address.toLowerCase());
-    return t ? t.symbol : null;
+    return resolveTokenSymbol(address, {
+        trackedTokens: state.trackedTokens,
+        wallets: state.wallets,
+    });
 }

 // Try to decode calldata using known ABIs.
@@ -85,8 +91,7 @@ function decodeCalldata(data, toAddress) {
    try {
        const parsed = erc20Iface.parseTransaction({ data });
        if (parsed) {
-            const token = TOKEN_BY_ADDRESS.get(toAddress.toLowerCase());
-            const tokenSymbol = token ? token.symbol : null;
+            const tokenSymbol = resolveTokenSymbol(toAddress, decimalsSources);
            // 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
@@ -242,8 +247,11 @@ function showTxApproval(details) {
    const approvedTx = details.approvedTx;

    const toAddr = approvedTx.to;
-    const token = toAddr ? TOKEN_BY_ADDRESS.get(toAddr.toLowerCase()) : null;
    const ethValue = formatEther(approvedTx.value || "0");
+    const sources = {
+        trackedTokens: state.trackedTokens,
+        wallets: state.wallets,
+    };

    // Build txInfo for status screens
    pendingTxDetails = {
@@ -251,14 +259,17 @@ function showTxApproval(details) {
        to: toAddr || "",
        amount: formatTxValue(ethValue),
        token: "ETH",
-        tokenSymbol: token ? token.symbol : null,
+        tokenSymbol: null,
    };

    // If this is an ERC-20 call, try to extract the real recipient and amount
    const decoded = decodeCalldata(approvedTx.data, toAddr || "");
    if (decoded && decoded.details) {
-        let decodedTokenAddr = null;
-        let decodedTokenSymbol = null;
+        // The asset the status summary is counted in: an ERC-20 call's Token
+        // contract, or a swap's input token. Its symbol is resolved from the
+        // same sources as the approval screen, so a non-bundled token the
+        // wallet knows is not carried onto the wait and success screens as ETH.
+        let assetAddr = null;
        for (const d of decoded.details) {
            if (d.label === "Recipient" && d.address) {
                pendingTxDetails.to = d.address;
@@ -266,20 +277,20 @@ function showTxApproval(details) {
            if (d.label === "Amount") {
                pendingTxDetails.amount = d.rawValue || d.value;
            }
-            if (d.label === "Token In" && d.isToken && d.address) {
-                const t = TOKEN_BY_ADDRESS.get(d.address.toLowerCase());
-                if (t) {
-                    decodedTokenAddr = d.address;
-                    decodedTokenSymbol = t.symbol;
-                }
+            if (
+                (d.label === "Token" || d.label === "Token In") &&
+                d.isToken &&
+                d.address
+            ) {
+                assetAddr = d.address;
            }
        }
-        if (token) {
-            pendingTxDetails.token = toAddr;
-            pendingTxDetails.tokenSymbol = token.symbol;
-        } else if (decodedTokenAddr) {
-            pendingTxDetails.token = decodedTokenAddr;
-            pendingTxDetails.tokenSymbol = decodedTokenSymbol;
+        if (assetAddr) {
+            pendingTxDetails.token = assetAddr;
+            pendingTxDetails.tokenSymbol = resolveTokenSymbol(
+                assetAddr,
+                sources,
+            );
        }
    }

@@ -30,6 +30,7 @@ const {
    displayedDecimals,
    transferAmountUnits,
 } = require("../../shared/transferAmount");
+const { assertWithinCeilings } = require("../../shared/approvalVerify");
 const {
    CODES,
    FEE_PENDING,
@@ -139,12 +140,17 @@ function show(txInfo) {

    // Balance (with inline USD)
    if (isErc20) {
-        const bal = txInfo.tokenBalance || "0";
-        const balUsd = tokenPrice ? parseFloat(bal) * tokenPrice : null;
-        $("confirm-balance").textContent = valueWithUsd(
-            bal + " " + symbol,
-            balUsd,
-        );
+        // null is a balance whose scale nothing knows, not a balance of zero
+        // (https://git.eeqj.de/sneak/AutistMask/issues/349). The send is
+        // refused at encode time for the same missing scale; what this line
+        // must not do is state a quantity nobody established.
+        const bal = txInfo.tokenBalance;
+        const balUsd =
+            tokenPrice && bal != null ? parseFloat(bal) * tokenPrice : null;
+        $("confirm-balance").textContent =
+            bal == null
+                ? "unknown (" + symbol + ")"
+                : valueWithUsd(bal + " " + symbol, balUsd);
    } else {
        const bal = txInfo.balance || "0";
        const balUsd = ethPrice ? parseFloat(bal) * ethPrice : null;
@@ -235,17 +241,22 @@ function renderValidation(txInfo) {
    }
    if (codes.includes(CODES.INSUFFICIENT_TOKEN)) {
        messages.push(
-            "Insufficient " +
-                symbol +
-                " balance. You have " +
-                txInfo.tokenBalance +
-                " " +
-                symbol +
-                " but are trying to send " +
-                txInfo.amount +
-                " " +
-                symbol +
-                ".",
+            txInfo.tokenBalance == null
+                ? "This token's balance is unknown, because nothing this" +
+                      " wallet can consult reports how many decimal places it" +
+                      " uses, so the amount you are trying to send cannot be" +
+                      " checked against it."
+                : "Insufficient " +
+                      symbol +
+                      " balance. You have " +
+                      txInfo.tokenBalance +
+                      " " +
+                      symbol +
+                      " but are trying to send " +
+                      txInfo.amount +
+                      " " +
+                      symbol +
+                      ".",
        );
    }
    if (codes.includes(CODES.INSUFFICIENT_ETH)) {
@@ -384,6 +395,46 @@ async function estimateGas(txInfo) {
    }
 }

+// Populate the transaction this send describes, enforce the fee bound against
+// the fees that were actually filled in, then sign and broadcast it. The send
+// pins no fee fields, so ethers fills maxFeePerGas and the gas limit from what
+// the configured RPC node answers, with nothing otherwise bounding what a
+// hostile node can set — the dApp path's ceilings never reached this one.
+// Populating before the check is what makes assertWithinCeilings() see the
+// same numbers that would be signed; it throws an ApprovalMismatchError when
+// the product gasLimit × maxFeePerGas is over the bound, which the caller
+// shows in the reserved error area rather than sending.
+async function populateVerifyAndSend(connectedSigner, tx) {
+    let request;
+    if (tx.token === "ETH") {
+        request = { to: tx.to, value: parseEther(tx.amount) };
+    } else {
+        const contract = new Contract(tx.token, ERC20_ABI, connectedSigner);
+        // 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. See transferAmount.js.
+        const amount = transferAmountUnits(
+            tx.amount,
+            tx.tokenDecimals,
+            await contract.decimals(),
+        );
+        request = await contract.transfer.populateTransaction(tx.to, amount);
+    }
+    const populated = await connectedSigner.populateTransaction(request);
+    assertWithinCeilings(populated);
+    return connectedSigner.sendTransaction(populated);
+}
+
+// Show a full-sentence send failure in the reserved errors box, the same
+// element and markup renderValidation() uses for messages carrying the user's
+// own numbers, so it never moves anything on the screen.
+function showSendError(message) {
+    const el = $("confirm-errors");
+    el.innerHTML = `<div class="text-xs">${escapeHtml(message)}</div>`;
+    el.style.visibility = "visible";
+}
+
 async function checkRecipientHistory(txInfo) {
    try {
        const provider = getProvider(state.rpcUrl, state.networkId);
@@ -457,29 +508,7 @@ function init(_ctx) {
            const provider = getProvider(state.rpcUrl, state.networkId);
            const connectedSigner = signer.connect(provider);

-            if (pendingTx.token === "ETH") {
-                tx = await connectedSigner.sendTransaction({
-                    to: pendingTx.to,
-                    value: parseEther(pendingTx.amount),
-                });
-            } else {
-                const contract = new Contract(
-                    pendingTx.token,
-                    ERC20_ABI,
-                    connectedSigner,
-                );
-                // 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);
-            }
+            tx = await populateVerifyAndSend(connectedSigner, pendingTx);

            // Best-effort: clear decrypted secret after use.
            // Note: JS strings are immutable; this nulls the reference but
@@ -488,6 +517,14 @@ function init(_ctx) {
            txStatus.showWait(pendingTx, tx.hash);
        } catch (e) {
            decryptedSecret = null;
+            // A fee over the bound is refused before anything is broadcast, so
+            // there is no transaction that may have reached the network to warn
+            // about: the message stays on the confirmation screen where the
+            // user can go back, rather than routing to the sent/failed screen.
+            if (e && e.approvalMismatch) {
+                showSendError(e.message);
+                return;
+            }
            const hash = tx ? tx.hash : null;
            txStatus.showError(pendingTx, hash, e.shortMessage || e.message);
        } finally {
@@ -501,4 +538,4 @@ function init(_ctx) {
    });
 }

-module.exports = { init, show, restore };
+module.exports = { init, show, restore, populateVerifyAndSend };
@@ -51,16 +51,12 @@ function clear() {
 // The lost-password screen holds no secret — a wallet name is not one —
 // but it is wiped on leave for the neighbouring reason: a typed
 // confirmation left standing in a hidden view is one click away from
-// destroying a wallet the user has since navigated off. The button is
-// re-enabled here too, so a screen left mid-delete is usable on re-entry.
+// destroying a wallet the user has since navigated off.
 function clearLostPassword() {
    lostPasswordIndex = null;
    $("delete-wallet-lost-name-input").value = "";
    $("delete-wallet-lost-flash").textContent = "";
    $("delete-wallet-lost-flash").style.visibility = "hidden";
-    const btn = $("btn-delete-wallet-lost-confirm");
-    btn.disabled = false;
-    btn.classList.remove("text-muted");
 }

 function show(walletIdx) {
@@ -98,6 +94,17 @@ function showLostPassword() {
 // cleanup and the accountsChanged broadcast cannot drift apart between
 // them.
 async function finishDelete(walletIdx) {
+    // Each route's confirm button was disabled by its own click handler
+    // before the delete ran. Re-enable both here, on the one path they
+    // share, so the two routes reset the same way and a second delete in
+    // the same popup session finds a live button instead of a dead one.
+    const passwordBtn = $("btn-delete-wallet-confirm");
+    passwordBtn.disabled = false;
+    passwordBtn.classList.remove("text-muted");
+    const lostPasswordBtn = $("btn-delete-wallet-lost-confirm");
+    lostPasswordBtn.disabled = false;
+    lostPasswordBtn.classList.remove("text-muted");
+
    const { activeAddressChanged } = removeWalletFromState(state, walletIdx);

    deleteWalletIndex = null;
@@ -187,8 +194,8 @@ function init(_ctx) {
        btn.disabled = true;
        btn.classList.add("text-muted");

-        // finishDelete() navigates, and the leave hook re-enables the
-        // button and wipes the typed name on the way out.
+        // finishDelete() re-enables the button; navigating away then runs
+        // the leave hook that wipes the typed name.
        await finishDelete(lostPasswordIndex);
    });

@@ -12,6 +12,7 @@
 // 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 { DEBUG } = require("../../shared/constants");
 const { escapeHtml } = require("../../shared/html");
 const { isDebug } = require("../../shared/log");
 const { formatUsd, getPrice } = require("../../shared/prices");
@@ -119,7 +120,11 @@ function updateDebugBanner(viewName) {
                "background:#c00;color:#fff;text-align:center;font-size:10px;padding:1px 0;font-family:monospace;position:sticky;top:0;z-index:9999;";
            document.body.prepend(banner);
        }
-        const suffix = viewName ? " (" + viewName + ")" : "";
+        // The view id is internal vocabulary; it helps while developing but
+        // means nothing to a user. Only a debug build appends it, gated on the
+        // compile-time DEBUG constant so a release build never shows it — not
+        // isDebug(), which is also true for a testnet or the runtime toggle.
+        const suffix = DEBUG && viewName ? " (" + viewName + ")" : "";
        if (debug && net.isTestnet) {
            banner.textContent = "DEBUG / INSECURE [TESTNET]" + suffix;
        } else if (net.isTestnet) {
@@ -229,6 +234,15 @@ function showFlash(msg, duration = 2000) {
    }, duration);
 }

+// A stored token balance as a number, or null when there is no number in it.
+// balances.js writes null for a holding whose scale nothing knows, and this
+// keeps that null from becoming a zero one dereference later.
+function unknownableAmount(balance) {
+    if (balance == null) return null;
+    const n = parseFloat(balance);
+    return Number.isFinite(n) ? n : null;
+}
+
 // One row of the balance list: symbol, quantity, fiat value.
 //
 // `symbol` is the ERC-20's own symbol() as the block explorer reported it,
@@ -236,9 +250,18 @@ function showFlash(msg, duration = 2000) {
 // 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.
+//
+// `amount` is null for a holding whose scale nothing knows
+// (https://git.eeqj.de/sneak/AutistMask/issues/349). There is no quantity to
+// print for it and no fiat value to derive from one, and printing 0.0000 for
+// a real holding is the failure this whole rule exists to prevent, so the row
+// says so instead.
 function balanceLine(symbol, amount, price, tokenId) {
-    const qty = amount.toFixed(4);
-    const usd = price ? formatUsd(amount * price) || "&nbsp;" : "&nbsp;";
+    const qty = amount === null ? "quantity unknown" : amount.toFixed(4);
+    const usd =
+        price && amount !== null
+            ? formatUsd(amount * price) || "&nbsp;"
+            : "&nbsp;";
    // 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)}"` : "";
@@ -265,7 +288,12 @@ function balanceLinesForAddress(addr, trackedTokens, showZero) {
    );
    const seen = new Set();
    for (const t of addr.tokenBalances || []) {
-        const bal = parseFloat(t.balance || "0");
+        // A null balance is a holding of an unstatable amount, not a holding
+        // of zero, so the show-zero setting has no say over it: hiding it
+        // would be asserting the zero nobody established. Anything that does
+        // not parse to a finite number is unknown for the same reason — the
+        // `|| "0"` this replaced turned both into a confident zero.
+        const bal = unknownableAmount(t.balance);
        if (bal === 0 && !showZero) continue;
        html += balanceLine(
            t.symbol,
@@ -298,11 +326,22 @@ function addressHoldsFunds(addr) {
    if (!addr) return false;
    if (parseFloat(addr.balance || "0") > 0) return true;
    for (const t of addr.tokenBalances || []) {
-        if (parseFloat(t.balance || "0") > 0) return true;
+        // A null balance is a holding whose amount could not be stated —
+        // balances.js drops a row of zero base units before the scale is
+        // consulted, so a row that survived with no quantity is holding
+        // something. Warning about funds must err towards warning.
+        const bal = unknownableAmount(t.balance);
+        if (bal === null || bal > 0) return true;
    }
    return false;
 }

+// The fewest characters of an address any caller may ask to display. The
+// 10-character cap inside truncateMiddle() is the other half of the same
+// guarantee; this is the half that used to be spelled out at each call
+// site, and is now enforced once in renderAddressHtml().
+const ADDRESS_MIN_DISPLAY_LEN = 32;
+
 // Truncate the middle of a string, replacing removed characters with "…".
 // Safety: refuses to truncate more than 10 characters, which is the maximum
 // that still prevents address spoofing attacks (see Display Consistency in
@@ -490,17 +529,29 @@ function attachCopyHandlers(container) {

 // Unified address rendering.
 //
-// Produces consistent HTML for any Ethereum address:
-//   • Color dot
-//   • Optional title (e.g. "Wallet 1 — Address 2") shown bold above address
-//   • Optional ENS name shown bold above address
-//   • Full address (or truncated via maxLen) with dashed-underline click-to-copy
-//   • Etherscan external link icon
+// Two stacked rows, in this order:
+//   1. Identity strip — colour dot, optional title (e.g. "Wallet 1 —
+//      Address 2") and the explorer link icon. Optional ENS name below it.
+//   2. The address itself, alone on a full-width row that never wraps
+//      (see .am-address in styles/main.css).
+//
+// The split is the point. Everything used to sit on one line: dot, address
+// and link together, with `break-all` to let the address fold when the line
+// ran out. In the wallet list, where the row also carried [info] and [x],
+// it ran out every time — the bug in #380 — and a folded address is a
+// spoofing hazard, not a cosmetic one. Nothing shares the address's row
+// now, so all 42 characters fit at every nesting depth the popup uses and
+// nothing has to be dropped or folded to make room.
 //
 // Options object:
 //   title    — wallet title string (from addressTitle)
 //   ensName  — ENS name string
-//   maxLen   — if set, truncate address display (min 32 chars enforced)
+//   maxLen   — if set, truncate address display. Floored at 32 characters
+//              here rather than by the caller: no view passes it any more
+//              (every address row is wide enough for all 42 characters),
+//              so a floor that lived in the callers would have gone away
+//              with them, and the "at least 32 characters" guarantee has
+//              to survive having no current callers to be a guarantee.
 //   noLink   — if true, omit etherscan link
 //
 // After inserting the returned HTML into the DOM, call
@@ -508,22 +559,22 @@ function attachCopyHandlers(container) {
 function renderAddressHtml(address, opts) {
    const { title, ensName, maxLen, noLink } = opts || {};
    const dot = addressDotHtml(address);
-    const displayAddr = maxLen ? truncateMiddle(address, maxLen) : address;
+    const displayAddr = maxLen
+        ? truncateMiddle(address, Math.max(ADDRESS_MIN_DISPLAY_LEN, maxLen))
+        : address;
    const link = etherscanAddressUrl(address);
    const extLink = noLink ? "" : etherscanLinkHtml(link);

    let html = "";
+    html += `<div class="flex items-center">${dot}`;
    if (title) {
-        html += `<div class="flex items-center font-bold">${dot}${escapeHtml(title)}</div>`;
+        html += `<span class="font-bold">${escapeHtml(title)}</span>`;
    }
+    html += `${extLink}</div>`;
    if (ensName) {
-        html += `<div class="flex items-center font-bold">${title ? "" : dot}${escapeHtml(ensName)}</div>`;
-    }
-    if (title || ensName) {
-        html += `<div class="flex items-center">${copyableHtml(displayAddr, "break-all")}${extLink}</div>`;
-    } else {
-        html += `<div class="flex items-center">${dot}${copyableHtml(displayAddr, "break-all")}${extLink}</div>`;
+        html += `<div class="font-bold">${escapeHtml(ensName)}</div>`;
    }
+    html += `<div class="am-address">${copyableHtml(displayAddr)}</div>`;
    return html;
 }

@@ -558,6 +609,7 @@ module.exports = {
    balanceLine,
    balanceLinesForAddress,
    addressHoldsFunds,
+    unknownableAmount,
    addressColor,
    addressDotHtml,
    escapeHtml,
@@ -9,7 +9,6 @@ const {
    addressTitle,
    escapeHtml,
    displaySymbol,
-    truncateMiddle,
    renderAddressHtml,
    attachCopyHandlers,
    pushCurrentView,
@@ -117,10 +116,13 @@ function renderHomeTxList(ctx) {
        const amountStr = tx.value
            ? escapeHtml(tx.value + " " + sym)
            : escapeHtml(sym);
+        // The counterparty used to be squeezed in beside the amount and
+        // truncated to whatever was left over. It gets its own row now and
+        // is shown whole; the title, when it is one of our own addresses,
+        // names it on the line above rather than replacing it.
        const title = addressTitle(counterparty, state.wallets);
-        const maxAddr = Math.max(32, 36 - Math.max(0, amountStr.length - 10));
-        const displayAddr = title || truncateMiddle(counterparty, maxAddr);
-        const addrStr = escapeHtml(displayAddr);
+        const titleStr = title ? escapeHtml(title) : "";
+        const addrStr = escapeHtml(counterparty);
        const dot = addressDotHtml(counterparty);
        const err = tx.isError ? " (failed)" : "";
        const opacity = tx.isError ? " opacity:0.5;" : "";
@@ -128,7 +130,8 @@ function renderHomeTxList(ctx) {
        const iso = escapeHtml(isoDate(tx.timestamp));
        html += `<div class="home-tx-row py-2 border-b border-border-light text-xs cursor-pointer hover:bg-hover" data-tx="${i}" style="${opacity}">`;
        html += `<div class="flex justify-between"><span class="text-muted" title="${iso}">${ago}</span><span>${dirLabel}${err}</span></div>`;
-        html += `<div class="flex justify-between"><span class="flex items-center">${dot}${addrStr}</span><span>${amountStr}</span></div>`;
+        html += `<div class="flex justify-between"><span class="flex items-center">${dot}${titleStr}</span><span>${amountStr}</span></div>`;
+        html += `<div class="am-address">${addrStr}</div>`;
        html += `</div>`;
        i++;
    }
@@ -252,17 +255,22 @@ function walletListHtml() {
                : "";
            const dot = addressDotHtml(addr.address);
            const titleBold = isActive ? "font-bold" : "";
-            html += `<div class="text-xs ${titleBold}">Address ${ai + 1}</div>`;
+            // [info] and [x] ride on the "Address N" line, which was empty
+            // to its right, so the address below gets the row to itself.
+            // They used to sit beside the address and take about a third of
+            // the width off it, which is what made a 42-character address
+            // fold onto a second line here and nowhere else (#380).
+            html += `<div class="flex text-xs items-center justify-between">`;
+            html += `<span class="flex items-center ${titleBold}">${dot}Address ${ai + 1}</span>`;
+            html += `<span class="flex-shrink-0 ml-1">${infoBtn}${removeBtn}</span>`;
+            html += `</div>`;
            if (addr.ensName) {
                // 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="text-xs font-bold">${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}${escapeHtml(addr.address)}</span>`;
-            html += `<span class="flex-shrink-0 ml-1">${infoBtn}${removeBtn}</span>`;
-            html += `</div>`;
+            html += `<div class="am-address text-xs">${escapeHtml(addr.address)}</div>`;
            const addrTotal = formatAddressTotal(getAddressValue(addr));
            html += `<div class="text-xs text-muted text-right min-h-[1rem]">${addrTotal || "&nbsp;"}</div>`;
            html += balanceLinesForAddress(
@@ -12,6 +12,7 @@ const {
 const { state, currentAddress } = require("../../shared/state");
 let ctx;
 const { getProvider } = require("../../shared/balances");
+const { resolveTokenDecimals } = require("../../shared/approvalAmount");
 const { resolveSymbol } = require("../../shared/tokenList");
 const { isLowHolderCount } = require("../../shared/holders");
 const { isSpoofedSymbol } = require("../../shared/symbolSpoof");
@@ -159,9 +160,14 @@ function updateSendBalance() {
            addr.tokenBalances,
            state.trackedTokens,
        );
-        const bal = tb ? tb.balance || "0" : "0";
+        // A null balance is a holding whose scale nothing knows. Saying "0"
+        // for it would be a claim about the amount; the send itself is
+        // refused later by transferAmountUnits() for the same missing scale.
+        const bal = tb ? tb.balance : "0";
        $("send-balance").textContent =
-            "Current balance: " + bal + " " + symbol;
+            bal == null
+                ? "Current balance: unknown (" + symbol + ")"
+                : "Current balance: " + bal + " " + symbol;
    }
 }

@@ -235,8 +241,45 @@ function init(_ctx) {
                addr.tokenBalances,
                state.trackedTokens,
            );
-            tokenBalance = tb ? tb.balance || "0" : "0";
-            tokenDecimals = tb ? tb.decimals : null;
+            // null carried through rather than flattened to "0": the confirm
+            // screen states an unknown balance as unknown, and
+            // validateTransfer() treats it as no balance to spend from, which
+            // is the fail-closed side of an amount nobody can check.
+            tokenBalance = tb ? (tb.balance ?? null) : "0";
+            // Resolved the same way balances.js resolved the scale it
+            // DISPLAYED this token's balance at: bundled list, then the user's
+            // tracked tokens, then the explorer. The stored
+            // tokenBalances[].decimals is the explorer's own answer alone, so
+            // reading it raw carries a null forward for a token the wallet
+            // does know the scale of — and displayedDecimals() then throws
+            // inside estimateGas(), which the confirmation screen reports as
+            // an unestimable fee. Unsendable, over a scale that was never in
+            // doubt (https://git.eeqj.de/sneak/AutistMask/issues/349).
+            // Still null when nothing knows: no fallback.
+            //
+            // Resolved WITH `wallets`, which balances.js does not pass: that
+            // adds explorerDecimals()'s cross-address check, so a contract two
+            // addresses report different scales for answers null rather than
+            // picking one. That check has to apply here, because this value
+            // encodes a transfer; balances.js is formatting one explorer row
+            // at fetch time and cannot consult a state it is in the middle of
+            // replacing.
+            tokenDecimals = resolveTokenDecimals(token, {
+                trackedTokens: state.trackedTokens,
+                wallets: state.wallets,
+            });
+            // The two resolutions can therefore differ, and where they do, the
+            // stored `balance` is a quantity computed at a scale this screen
+            // has just declined to stand behind. Stating it would leave
+            // validateTransfer() checking the amount against a number the
+            // wallet does not vouch for, and — since the unknown-balance path
+            // is gated on the balance, not on the scale — would leave the
+            // fee-estimate failure as the only thing on the confirmation
+            // screen, which says nothing about decimals. Unknown scale means
+            // unknown balance. Only a stored quantity is withdrawn: the "0"
+            // for a token that has no row at all is an absence of holdings,
+            // which is true at every scale.
+            if (tb && tokenDecimals === null) tokenBalance = null;
        }

        ctx.showConfirmTx({
@@ -137,10 +137,16 @@ function render() {
        if (tx.contractAddress) {
            const dot = addressDotHtml(tx.contractAddress);
            const link = explorerUrl("token", tx.contractAddress);
+            // Hand-rolled rather than renderAddressHtml() because the
+            // link goes to the explorer's /token/ page, not /address/.
+            // Same two-row shape though: dot and link on the strip, the
+            // contract address alone on the row below it.
            tokenContractEl.innerHTML =
                `<div class="flex items-center">${dot}` +
-                copyableHtml(tx.contractAddress, "break-all") +
                etherscanLinkHtml(link) +
+                `</div>` +
+                `<div class="am-address">` +
+                copyableHtml(tx.contractAddress) +
                `</div>`;
            tokenContractSection.classList.remove("hidden");
        } else {
@@ -13,7 +13,7 @@ const {
    displaySymbol,
    clearViewStack,
 } = require("./helpers");
-const { TOKEN_BY_ADDRESS } = require("../../shared/tokenList");
+const { resolveTokenSymbol } = require("../../shared/approvalAmount");
 const { state } = require("../../shared/state");
 const { getProvider } = require("../../shared/balances");
 const { log } = require("../../shared/log");
@@ -232,9 +232,15 @@ function showSuccess(txInfo, txHash, blockNumber) {
    ctx.doRefreshAndRender();
 }

+// The symbol shown for a decoded token line, resolved from the bundled list,
+// the tokens the user tracks, and the explorer's report — the same chain the
+// approval screen uses. Null when no source names one, so the line keeps
+// saying `Unknown token`.
 function tokenLabel(address) {
-    const t = TOKEN_BY_ADDRESS.get(address.toLowerCase());
-    return t ? t.symbol : null;
+    return resolveTokenSymbol(address, {
+        trackedTokens: state.trackedTokens,
+        wallets: state.wallets,
+    });
 }

 function decodedDetailsHtml(decoded) {
@@ -23,32 +23,14 @@
 // 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");
+// reporting that call's result. toDecimals() is that check, shared with the
+// send path rather than copied: the bundled list stores numbers, the
+// explorer's copy arrives as a string, and a token the user added by hand
+// carries whatever lookupTokenInfo() got back, so the accepted types are
+// enumerated rather than coerced.
+const { toDecimals } = require("./transferAmount");
 const { 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;
-}
+const { isSpoofedSymbol } = require("./symbolSpoof");

 // Every decimals the explorer reported for this contract, across all the
 // addresses whose balances have been fetched. They describe one contract, so
@@ -93,6 +75,59 @@ function resolveTokenDecimals(tokenAddress, sources) {
    return explorerDecimals(lower, sources && sources.wallets);
 }

+// Every symbol the explorer reported for this contract, across the addresses
+// whose balances have been fetched. The counterpart to explorerDecimals(): one
+// contract, so the reports should agree, and a set that does not agree is a
+// name this screen has no way to choose between.
+function explorerSymbol(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;
+                if (!tb.symbol) continue;
+                if (found !== null && found !== tb.symbol) return null;
+                found = tb.symbol;
+            }
+        }
+    }
+    return found;
+}
+
+// The symbol to label a token with, or null when no source the wallet trusts
+// names one — in which case the screen keeps saying `Unknown token` rather than
+// guessing. The bundled list, then the tokens the user tracks, then what the
+// explorer reported: the same sources and the same precedence
+// resolveTokenDecimals() uses, so a token's name and its scale are drawn from
+// the same place and the two can no longer disagree about which sources they
+// trust. `sources` is { trackedTokens, wallets }, shaped as on `state`.
+//
+// A tracked or explorer-reported symbol is attacker-influenced text, so it is
+// held to the spoof rule (symbolSpoof.js): a candidate that wears a bundled or
+// native ticker from a contract not entitled to it is refused and the next
+// source tried, so resolving a symbol never becomes a new way to claim a known
+// ticker. The bundled list is the wallet's own data and is trusted as it is.
+function resolveTokenSymbol(tokenAddress, sources) {
+    const lower = (tokenAddress || "").toLowerCase();
+    if (!lower) return null;
+
+    const bundled = TOKEN_BY_ADDRESS.get(lower);
+    if (bundled && bundled.symbol) return bundled.symbol;
+
+    const tracked = ((sources && sources.trackedTokens) || []).find(
+        (t) => (t.address || "").toLowerCase() === lower,
+    );
+    const candidates = [];
+    if (tracked && tracked.symbol) candidates.push(tracked.symbol);
+    const reported = explorerSymbol(lower, sources && sources.wallets);
+    if (reported) candidates.push(reported);
+
+    for (const symbol of candidates) {
+        if (!isSpoofedSymbol(symbol, tokenAddress)) return symbol;
+    }
+    return null;
+}
+
 // 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
@@ -103,5 +138,6 @@ function unknownDecimalsAmount(rawAmount) {

 module.exports = {
    resolveTokenDecimals,
+    resolveTokenSymbol,
    unknownDecimalsAmount,
 };
@@ -51,6 +51,7 @@
 const {
    Transaction,
    accessListify,
+    formatEther,
    getAddress,
    getBytes,
    verifyMessage,
@@ -134,10 +135,19 @@ const FORBIDDEN_FIELDS = [
 const MAX_GAS_LIMIT = 100000000n;

 // 100,000 gwei per gas: orders of magnitude above the highest fee either
-// supported network has produced, and low enough to catch a fee that would
-// hand the validator the balance.
+// supported network has produced.
 const MAX_FEE_PER_GAS = 100000000000000n;

+// The largest total fee this wallet will sign, in wei. The two ceilings above
+// bound the gas limit and the price per gas each on its own, but the fee a
+// validator is actually paid is their product, and a gas limit and a price
+// that are each under their own ceiling still multiply to thousands of ETH —
+// 30,000,000 gas at 100,000 gwei is about 3,000 ETH. Bounding the product is
+// what catches a fee that would hand the validator the balance; the per-field
+// ceilings alone do not. A full 30,000,000-gas block at 33 gwei reaches this,
+// which no ordinary wallet transaction approaches.
+const MAX_TOTAL_FEE = 1000000000000000000n; // 1 ETH
+
 // A refusal to act on an artifact: it is not the thing that was approved, so
 // the approval it was offered against is spent and must not be retried. Every
 // throw in this module is one of these; the background distinguishes them from
@@ -384,6 +394,28 @@ function assertWithinCeilings(tx) {
            );
        }
    }
+    // The product: gasLimit × the most this transaction could pay per gas —
+    // maxFeePerGas for a type-2 transaction, gasPrice for a legacy or type-1
+    // one. This is the fee a gas-consuming contract can really extract, and it
+    // is the bound the two per-field ceilings above cannot express.
+    if (present(tx.gasLimit)) {
+        const gasLimit = normalizeQuantity(tx.gasLimit, "gas limit");
+        let price = null;
+        if (present(tx.maxFeePerGas)) {
+            price = normalizeQuantity(tx.maxFeePerGas, "maximum fee per gas");
+        } else if (present(tx.gasPrice)) {
+            price = normalizeQuantity(tx.gasPrice, "gas price");
+        }
+        if (price !== null && gasLimit * price > MAX_TOTAL_FEE) {
+            throw refuse(
+                "This transaction would allow a network fee of up to " +
+                    formatEther(gasLimit * price) +
+                    " ETH, which is more than the " +
+                    formatEther(MAX_TOTAL_FEE) +
+                    " ETH this wallet will sign for.",
+            );
+        }
+    }
 }

 // Refuse a field only a transaction type this wallet does not sign can carry.
@@ -775,4 +807,5 @@ module.exports = {
    TX_STAGE_NONCE,
    MAX_GAS_LIMIT,
    MAX_FEE_PER_GAS,
+    MAX_TOTAL_FEE,
 };
@@ -15,6 +15,8 @@ const { deriveAddressFromXpub } = require("./wallet");
 const { TOKEN_BY_ADDRESS } = require("./tokenList");
 const { LOW_HOLDER_THRESHOLD, parseHoldersCount } = require("./holders");
 const { isSpoofedSymbol } = require("./symbolSpoof");
+const { toDecimals } = require("./transferAmount");
+const { resolveTokenDecimals } = require("./approvalAmount");

 // Use a static network to skip auto-detection (which can fail and cause
 // "could not coalesce error" on some RPC endpoints like Cloudflare).
@@ -66,10 +68,28 @@ function formatTokenBalance(raw, decimals) {
    return parts[0] + "." + dec;
 }

+// The explorer's reported holding as an exact base-unit integer, or null when
+// it reported nothing usable. Base units carry no scale, so this value is
+// meaningful before the scale is known — which is what lets a holding of zero
+// be recognised as zero without guessing a scale to divide it by.
+function rawUnits(value) {
+    if (typeof value === "bigint") return value >= 0n ? value : null;
+    if (typeof value === "number") {
+        return Number.isSafeInteger(value) && value >= 0 ? BigInt(value) : null;
+    }
+    if (typeof value !== "string" || !/^[0-9]+$/.test(value)) return null;
+    return BigInt(value);
+}
+
 // Fetch token balances for a single address from Blockscout.
-// Returns [{ address, symbol, decimals, balance }].
+// Returns [{ address, name, symbol, decimals, balance, holders }].
 // Filters out spam: only shows tokens that are in the known token list,
 // explicitly tracked by the user, or have >= 1000 holders.
+//
+// `decimals` and `balance` are each null when the answer is unknown, the same
+// way `holders` already is. Absence is never filled in here: this is the
+// upstream of every screen that displays a token amount, so a value invented
+// at this point is indistinguishable from a real one everywhere below it.
 async function fetchTokenBalances(address, blockscoutUrl, trackedTokens) {
    try {
        const resp = await debugFetch(
@@ -94,11 +114,46 @@ async function fetchTokenBalances(address, blockscoutUrl, trackedTokens) {
            // is unchanged.
            const type = String(item.token?.type || "").toUpperCase();
            if (type !== "ERC-20") continue;
-            const decimals = parseInt(item.token.decimals || "18", 10);
-            const bal = formatTokenBalance(item.value || "0", decimals);
-            if (bal === "0.0") continue;

            const tokenAddr = (item.token.address_hash || "").toLowerCase();
+
+            // What the explorer reported, or null. NEVER a default: this
+            // value is written to state and every later reader — the approval
+            // screen's amount line, the swap lines, the Send screen — takes it
+            // as the token's resolved scale. A fabricated 18 reads exactly
+            // like a real 18 at that point, so it does not merely display the
+            // wrong quantity, it walks straight past the refusal those screens
+            // already have for a scale nobody knows
+            // (https://git.eeqj.de/sneak/AutistMask/issues/349).
+            const decimals = toDecimals(item.token.decimals);
+
+            const raw = rawUnits(item.value);
+            // No usable amount at all is nothing to list, exactly as a
+            // formatted "0.0" was before. Checked on the base-unit integer so
+            // it does not depend on knowing the scale: zero base units is zero
+            // tokens at every scale, and a value the explorer did not report
+            // as an integer is not a holding.
+            if (raw === null || raw === 0n) continue;
+
+            // The scale this row's balance is DISPLAYED at, which is not the
+            // same question as what the explorer said. The bundled list and
+            // the tokens the user tracks both outrank the explorer already
+            // (resolveTokenDecimals), so a token they know keeps showing its
+            // real quantity even when the explorer's entry omits decimals.
+            // Only what neither of them nor the explorer knows is unknown.
+            // The stored `decimals` above stays the explorer's own answer
+            // either way: copying another source into it would make
+            // explorerDecimals()'s disagreement check compare something other
+            // than explorer values.
+            const known = resolveTokenDecimals(tokenAddr, { trackedTokens });
+            const scale = known !== null ? known : decimals;
+            // null is a holding of an amount that cannot be stated, which is
+            // not the same as a holding of zero, and must never render as one.
+            // With a scale, the display filter proper applies: a balance that
+            // rounds to zero at six places is dust and is not listed. Without
+            // one there is no such judgement to make, and the row is kept.
+            const bal = scale === null ? null : formatTokenBalance(raw, scale);
+            if (bal === "0.0") continue;
            // null means the explorer reported no count, which is not the
            // same as a count of zero.  This gate is not the low-holder
            // display filter: it has no user-facing off switch and governs
@@ -127,7 +182,15 @@ async function fetchTokenBalances(address, blockscoutUrl, trackedTokens) {
                address: item.token.address_hash,
                name: item.token.name || "",
                symbol: item.token.symbol || "???",
+                // null means the explorer reported no usable scale — unknown,
+                // not 18. Distinguishable from a real 18 at read time is the
+                // entire point: resolveTokenDecimals() falls through a null to
+                // its refusal, and takes an 18 as the answer.
                decimals: decimals,
+                // null means nothing anywhere knows the scale, so there is no
+                // token quantity to state. Not "0.0": a nonzero holding shown
+                // as zero is the same lie in the balance list that the
+                // approval screens refuse to tell.
                balance: bal,
                holders: holders,
            });
@@ -22,8 +22,15 @@ const BUILD_DEBUG_MARKER = DEBUG
    ? "autistmask-build-debug=on"
    : "autistmask-build-debug=off";

-const DEBUG_MNEMONIC =
-    "cube evolve unfold result inch risk jealous skill hotel bulb night wreck";
+// Behind DEBUG for the same reason BUILD_DEBUG_MARKER is above: in a release
+// build __BUILD_DEBUG__ is a compile-time false, esbuild drops this branch, and
+// the phrase never reaches a distributed bundle. The literal used to survive as
+// dead text because module.exports keeps this const live even though wallet.js's
+// only use of it is folded away; making the value itself fold to null removes
+// it. script/verify-build fails a release build if the phrase appears anyway.
+const DEBUG_MNEMONIC = DEBUG
+    ? "cube evolve unfold result inch risk jealous skill hotel bulb night wreck"
+    : null;

 const ETHEREUM_MAINNET_CHAIN_ID = "0x1";
 const ETHEREUM_SEPOLIA_CHAIN_ID = "0xaa36a7";
@@ -85,6 +85,14 @@ function isRecord(value) {
 // alternative — refusing the whole record — sends a user whose wallets are
 // perfectly readable to an export-or-erase screen over a token list. An entry
 // that is a record with a text address is kept verbatim, extra fields and all.
+//
+// Verbatim is load-bearing for the fields BESIDE the address. A tokenBalances
+// entry carries `decimals: null` and `balance: null` when nothing knows the
+// token's scale (src/shared/balances.js,
+// https://git.eeqj.de/sneak/AutistMask/issues/349), and those nulls are the
+// record that the value is unknown. Only `address` decides whether an entry
+// survives, so an unknown-scale holding is kept — flooring a null here to some
+// default would put the guess back one layer down from where it was removed.
 function tokenRefs(value) {
    if (!Array.isArray(value)) return [];
    return value.filter(
@@ -78,9 +78,18 @@ function getAddressValue(addr) {
    let usd = parseFloat(addr.balance || "0") * prices.ETH;
    let partial = false;
    for (const token of addr.tokenBalances || []) {
-        const tokenBal = parseFloat(token.balance || "0");
+        // A null balance is a holding whose scale nothing knows, so it has no
+        // quantity to price — but it is still a holding, and a total that
+        // silently omits it would read as complete. That is exactly what
+        // `partial` is for (https://git.eeqj.de/sneak/AutistMask/issues/349).
+        if (token.balance == null) {
+            partial = true;
+            continue;
+        }
+        const tokenBal = parseFloat(token.balance);
        // A balance of zero is not a holding: it can neither add to the total
-        // nor make it incomplete.
+        // nor make it incomplete. Anything that is not a number at all is not
+        // a holding this can price either, and is left to the same rule.
        if (!(tokenBal > 0)) continue;
        if (prices[token.symbol]) {
            usd += tokenBal * prices[token.symbol];
@@ -33,10 +33,21 @@
 // tests/persistedFieldContract.test.js: one row per persisted field, naming
 // the property that field's floor is claimed to have, and PROVING it by
 // driving the real code with hostile values — the gate for a field the gate
-// refuses, normalizePersisted() for a field it floors, and a boot of the real
-// popup entry point for a field whose only defence is that nothing
-// dereferences it structurally. A field added to PERSISTED_FIELDS with no row
-// fails that suite; so does a row whose claim is false.
+// refuses, normalizePersisted() for a field it floors, and, for a field whose
+// only defence is that nothing dereferences it structurally, a boot of the
+// real popup entry point onto EVERY view the popup can reopen onto.
+//
+// That last part is the whole point, because this defect class lives on the
+// RESTORE path and not on Home. Take the claim NARROWLY, exactly as that file
+// states it: what those boots prove is no structural dereference on the code
+// paths a WHOLLY-CORRUPTED PROFILE takes — which is not every path a stored
+// record takes. Not driven: any pairing of values the four slots do not
+// produce, a view only forward navigation opens, anything behind a click, and
+// everything a healthy profile reaches. Within that boundary the verdict is
+// unconditional, including a dereference that takes two corrupted fields at
+// once. That suite also goes red on a field that gains a floor while its row
+// still claims it has none, and on a field added to PERSISTED_FIELDS with no
+// row at all.
 //
 // That test exists because this comment did not work. It carried a
 // hand-written justification per field, and it shipped a false one in three
@@ -11,6 +11,10 @@ const { log, debugFetch } = require("./log");
 const { TOKEN_BY_ADDRESS } = require("./tokenList");
 const { parseHoldersCount, isLowHolderCount } = require("./holders");
 const { isSpoofedSymbol } = require("./symbolSpoof");
+// The uint8 test every scale in this wallet goes through. Shared, not copied:
+// a scale is either reported or it is unknown, and "unknown" must mean the
+// same thing here as it does on the screens that refuse to format one.
+const { toDecimals } = require("./transferAmount");
 // The plain 4-decimal rule. The history and balance lists deliberately keep
 // truncation without the approval screens' nonzero floor: the transaction
 // detail view is the authoritative record and already shows exact precision.
@@ -92,21 +96,37 @@ function parseTx(tx, addrLower) {
 function parseTokenTransfer(tt, addrLower) {
    const from = tt.from?.hash || "";
    const to = tt.to?.hash || "";
-    const decimals = parseInt(tt.total?.decimals || "18", 10);
+    // The explorer's own answer, or null. Never a default: a transfer of
+    // 5000000000 units formatted at a guessed 18 reads as 0.000000005, and
+    // nothing downstream can tell that from a real 18-decimal transfer of
+    // that size. `parseInt(x || "18", 10)` also collapsed a genuine scale of
+    // ZERO into 18 (https://git.eeqj.de/sneak/AutistMask/issues/246).
+    const decimals = toDecimals(tt.total?.decimals);
    const rawVal = tt.total?.value || "0";
    const direction =
        normalizeAddress(from) === addrLower ? "sent" : "received";
    const sym = tt.token?.symbol || "?";
+    // Without a scale there is no token quantity, so none is stated: the list
+    // row falls back to the symbol alone and the detail screen to its
+    // direction label, exactly as the contract-call rows above already do.
+    // The exact figure is not lost — it is the base-unit line below, which is
+    // the one number that needs no scale to be true.
+    const formatted =
+        decimals === null ? "" : formatTxValue(formatUnits(rawVal, decimals));
+    const exact = decimals === null ? "" : formatUnits(rawVal, decimals);
    return {
        hash: tt.transaction_hash,
        blockNumber: tt.block_number,
        timestamp: Math.floor(new Date(tt.timestamp).getTime() / 1000),
        from: from,
        to: to,
-        value: formatTxValue(formatUnits(rawVal, decimals)),
-        exactValue: formatUnits(rawVal, decimals),
+        value: formatted,
+        exactValue: exact,
        rawAmount: rawVal,
-        rawUnit: sym + " base units (10^-" + decimals + ")",
+        rawUnit:
+            decimals === null
+                ? sym + " base units (decimals unknown)"
+                : sym + " base units (10^-" + decimals + ")",
        valueGwei: null,
        symbol: sym,
        direction: direction,
@@ -52,7 +52,7 @@ function mismatchMessage(displayed, onChain) {
    );
 }

-// A decimals value from either source as a number, or null if it is not one.
+// A decimals value from any 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.
@@ -60,7 +60,16 @@ function mismatchMessage(displayed, onChain) {
 // 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.
+// against it. Absence answers null and never a default, and a real scale of
+// ZERO answers 0 — the two are different answers, which is the whole point:
+// a falsy-collapsing `value || 18` cannot tell them apart, and neither can a
+// reader of what it wrote (https://git.eeqj.de/sneak/AutistMask/issues/246).
+//
+// Exported because every module that has to decide whether it knows a token's
+// scale needs exactly this test, and three separate copies of it is three
+// places for the answer to drift: approvalAmount.js resolves the scale the
+// approval screens display at, and balances.js decides what the explorer
+// actually reported before it is stored.
 function toDecimals(value) {
    let n;
    if (typeof value === "number") {
@@ -110,6 +119,7 @@ module.exports = {
    displayedDecimals,
    transferAmountUnits,
    mismatchMessage,
+    toDecimals,
    MAX_DECIMALS,
    UNKNOWN_DISPLAYED_DECIMALS_MESSAGE,
    UNREADABLE_CONTRACT_DECIMALS_MESSAGE,
@@ -2,10 +2,10 @@
 // swap details.  Designed to be extended with other DEX decoders later.

 const { Interface, AbiCoder, getBytes, formatUnits } = require("ethers");
-const { TOKEN_BY_ADDRESS } = require("./tokenList");
 const { truncateAmountNeverZero } = require("./amountDisplay");
 const {
    resolveTokenDecimals,
+    resolveTokenSymbol,
    unknownDecimalsAmount,
 } = require("./approvalAmount");

@@ -123,9 +123,8 @@ function tokenInfo(address, sources) {
    if (address === "0x0000000000000000000000000000000000000000") {
        return { symbol: "ETH", decimals: 18, address: null };
    }
-    const t = TOKEN_BY_ADDRESS.get(address.toLowerCase());
    return {
-        symbol: t ? t.symbol : null,
+        symbol: resolveTokenSymbol(address, sources),
        decimals: resolveTokenDecimals(address, sources),
        address,
    };
@@ -0,0 +1,58 @@
+// Adding a second wallet accepts a password different from the first one's
+// with nothing on screen saying the two are separate — each wallet has its
+// own encryptedSecret, so per-wallet passwords are by design, but the add
+// screen said only "Choose a password"
+// (https://git.eeqj.de/sneak/AutistMask/issues/374).
+//
+// The fix is copy: a note on the password screen that says each wallet has
+// its own password and this one need not match. It is only meaningful once
+// a wallet exists — on the very first wallet there is no other password to
+// be separate from — so it is shown then and hidden otherwise. These boot
+// the real popup and reach the add-wallet screen through the same button a
+// user presses, so the note's visibility is decided by the real show().
+
+const {
+    bootPopup,
+    cleanupPopup,
+    unversionedValidProfile,
+    POPUP_HTML,
+} = require("./support/popupBoot");
+
+const NOTE = "add-wallet-separate-password-note";
+
+afterEach(() => {
+    cleanupPopup();
+});
+
+describe("second-wallet password note", () => {
+    test("hidden while onboarding the first wallet", async () => {
+        const page = await bootPopup(undefined);
+        expect(page.pageErrors).toEqual([]);
+        await page.click("btn-welcome-add");
+        expect(page.visibleViews()).toContain("add-wallet");
+        expect(page.hidden(NOTE)).toBe(true);
+    });
+
+    test("shown when a wallet already exists", async () => {
+        const page = await bootPopup(unversionedValidProfile());
+        expect(page.pageErrors).toEqual([]);
+        await page.click("btn-main-add-wallet");
+        expect(page.visibleViews()).toContain("add-wallet");
+        expect(page.hidden(NOTE)).toBe(false);
+    });
+
+    // The copy states the two facts the definition of done asks for — each
+    // wallet has its own password, and this one need not match — and stays
+    // consistent with the no-password-reset reality of
+    // https://git.eeqj.de/sneak/AutistMask/issues/312 by not promising any
+    // recovery or reset here.
+    test("the note says the password is per-wallet and need not match", () => {
+        const note = /id="add-wallet-separate-password-note"[^>]*>([^]*?)<\/p>/
+            .exec(POPUP_HTML)[1]
+            .replace(/\s+/g, " ")
+            .trim();
+        expect(note).toContain("its own");
+        expect(note).toContain("need not match");
+        expect(note).not.toMatch(/recover|reset/i);
+    });
+});
@@ -143,16 +143,18 @@ describe("decodeCalldata amount", () => {
        state.trackedTokens = [
            { address: NOVEL_TOKEN, symbol: "NOVEL", decimals: 6 },
        ];
+        // The tracked entry supplies both: the scale (5000.0000) and, since
+        // issue #323, the symbol that the scale is counted in.
        expect(
            amountLine(transferData(FIVE_THOUSAND_AT_SIX), NOVEL_TOKEN),
-        ).toBe("5000.0000");
+        ).toBe("5000.0000 NOVEL");
    });

    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");
+        ).toBe("5000.0000 NOVEL");
    });

    test("transfer of an unknown-decimals token shows base units, not a number", () => {
@@ -172,7 +174,7 @@ describe("decodeCalldata amount", () => {
            { address: NOVEL_TOKEN, symbol: "NOVEL", decimals: 6 },
        ];
        expect(amountLine(approveData(FIVE_THOUSAND_AT_SIX), NOVEL_TOKEN)).toBe(
-            "5000.0000",
+            "5000.0000 NOVEL",
        );
    });

@@ -212,6 +212,24 @@ describe("prepareApprovalTx", () => {
        ).rejects.toThrow(/gas limit no network this wallet supports/);
    });

+    // The combined bound at population: a gas limit and a fee that are each
+    // under their own ceiling but multiply to thousands of ETH is refused
+    // before the approval window opens, so the user is never shown a
+    // balance-draining fee to click past.
+    test("refuses a fee whose product with the gas limit is over the bound", async () => {
+        const gouging = providerWith({
+            estimateGas: async () => 30000000n,
+            getFeeData: async () => ({
+                gasPrice: MAX_FEE_PER_GAS,
+                maxFeePerGas: MAX_FEE_PER_GAS,
+                maxPriorityFeePerGas: 1000000000n,
+            }),
+        });
+        await expect(
+            prepareApprovalTx(gouging, signer.address, TX_PARAMS),
+        ).rejects.toThrow(/network fee of up to/);
+    });
+
    // No approval and no window: the failure goes back to the page the click
    // came from, in a sentence.
    test("reports a failed estimate as a full sentence", async () => {
@@ -28,6 +28,7 @@ const {
    TX_STAGE_NONCE,
    MAX_GAS_LIMIT,
    MAX_FEE_PER_GAS,
+    MAX_TOTAL_FEE,
 } = require("../src/shared/approvalVerify");
 const { prepareApprovalTx } = require("../src/shared/approvalTx");
 const { getSignerForAddress } = require("../src/shared/wallet");
@@ -475,18 +476,131 @@ describe("verifySignedTx field comparison", () => {
                assertWithinCeilings({ [key]: MAX_FEE_PER_GAS + 1n }),
            ).toThrow(/fee per gas far above any plausible value/);
        }
+        // Each field at its own ceiling multiplies to about 10,000 ETH, which
+        // is exactly the combination the per-field ceilings cannot see and the
+        // product bound is for: it is refused, not accepted.
        expect(() =>
            assertWithinCeilings({
                gasLimit: MAX_GAS_LIMIT,
                maxFeePerGas: MAX_FEE_PER_GAS,
                maxPriorityFeePerGas: MAX_FEE_PER_GAS,
            }),
+        ).toThrow(/network fee of up to/);
+        // An ordinary transaction — a modest gas limit and a modest fee, each
+        // far under its ceiling and their product far under the bound — passes.
+        expect(() =>
+            assertWithinCeilings({
+                gasLimit: 21000n,
+                maxFeePerGas: 2000000000n,
+                maxPriorityFeePerGas: 1000000000n,
+            }),
        ).not.toThrow();
        // Nothing to bound is not a failure: a type 2 approval carries no gas
        // price, and a bare object must not be refused for lacking one.
        expect(() => assertWithinCeilings({})).not.toThrow();
    });

+    // The defect this issue closes: gasLimit and maxFeePerGas each under their
+    // own ceiling, but their product — the fee a gas-consuming contract can
+    // really extract — thousands of ETH. The per-field ceilings accept it; the
+    // product bound refuses it, on either side of the screen.
+    describe("the combined fee bound", () => {
+        // A gas limit and a fee that are each comfortably under their own
+        // ceiling but multiply to well over 1 ETH: 30,000,000 gas at 100,000
+        // gwei is about 3,000 ETH.
+        const OVER = { gasLimit: 30000000n, maxFeePerGas: 100000000000000n };
+
+        test("each field is under its own ceiling", () => {
+            expect(OVER.gasLimit).toBeLessThan(MAX_GAS_LIMIT);
+            expect(OVER.maxFeePerGas).toBeLessThanOrEqual(MAX_FEE_PER_GAS);
+            expect(OVER.gasLimit * OVER.maxFeePerGas).toBeGreaterThan(
+                MAX_TOTAL_FEE,
+            );
+        });
+
+        test("assertWithinCeilings refuses the product over the bound", () => {
+            expect(() =>
+                assertWithinCeilings({
+                    ...OVER,
+                    maxPriorityFeePerGas: 1000000000n,
+                }),
+            ).toThrow(/network fee of up to 3000\.0 ETH/);
+        });
+
+        test("assertWithinCeilings bounds a legacy gasPrice the same way", () => {
+            expect(() =>
+                assertWithinCeilings({
+                    gasLimit: OVER.gasLimit,
+                    gasPrice: OVER.maxFeePerGas,
+                }),
+            ).toThrow(/network fee of up to/);
+        });
+
+        // The boundary itself, pinned rather than only some value well past
+        // it. Both fields stay under their own ceilings, so it is the product
+        // and nothing else that decides these two cases: a gas limit of 10,000
+        // at the per-gas ceiling is exactly 1 ETH.
+        test("assertWithinCeilings accepts a product exactly at the bound and refuses one wei over", () => {
+            expect(MAX_FEE_PER_GAS * 10000n).toBe(MAX_TOTAL_FEE);
+            expect(() =>
+                assertWithinCeilings({
+                    gasLimit: 10000n,
+                    maxFeePerGas: MAX_FEE_PER_GAS,
+                }),
+            ).not.toThrow();
+            expect(() =>
+                assertWithinCeilings({
+                    gasLimit: 10001n,
+                    maxFeePerGas: MAX_FEE_PER_GAS,
+                }),
+            ).toThrow(/network fee of up to/);
+        });
+
+        // The dApp path: an artifact whose fee is within each field's ceiling
+        // but over the product bound, both displayed and signed, is refused at
+        // verification just as it is at population.
+        test("verifySignedTx refuses an over-bound product even when displayed", async () => {
+            const raw = await signedWith(OVER);
+            expect(() =>
+                verifySignedTx(
+                    raw,
+                    approvedFor(TX_PARAMS, OVER),
+                    signer.address,
+                    SELECTED,
+                ),
+            ).toThrow(/network fee of up to/);
+        });
+
+        test("verifySignedTx accepts a product just under the bound", async () => {
+            // 21,000 gas at 40 gwei is 0.00084 ETH — an ordinary send.
+            const under = { gasLimit: 21000n, maxFeePerGas: 40000000000n };
+            expect(under.gasLimit * under.maxFeePerGas).toBeLessThan(
+                MAX_TOTAL_FEE,
+            );
+            const raw = await signedWith(under);
+            expect(() =>
+                verifySignedTx(
+                    raw,
+                    approvedFor(TX_PARAMS, under),
+                    signer.address,
+                    SELECTED,
+                ),
+            ).not.toThrow();
+        });
+
+        test("the refusal names the fee and the limit in a full sentence", () => {
+            try {
+                assertWithinCeilings(OVER);
+                throw new Error("expected a rejection");
+            } catch (e) {
+                expect(e.approvalMismatch).toBe(true);
+                expect(e.message).toMatch(/^[A-Z].*\.$/);
+                expect(e.message).toContain("3000.0 ETH");
+                expect(e.message).toContain("1.0 ETH");
+            }
+        });
+    });
+
    test("every field mismatch is a refusal, not a warning", async () => {
        const raw = await signedWith({ nonce: 8 });
        try {
@@ -1541,6 +1541,149 @@ describe("a claimed approval outlives every other retirement path", () => {
    });
 });

+// The approval popup connects a port named for its approval whatever the
+// approval's kind, so a decision or a disconnect on that port can reach a
+// transaction approval. Both must be declined: the port decides only
+// site-connection approvals, and settling a transaction approval it does not
+// own — while an attempt is broadcasting behind it — is the round-3 fund-loss
+// bug, where the page is told the request was rejected as the transaction goes
+// out. These three paths route through settleApproval() and, before this
+// suite, were exercised only against site approvals.
+describe("the site-connection port never retires a transaction approval", () => {
+    async function txMidBroadcast() {
+        const bg = loadBackground();
+        const pending = bg.requestTx();
+        await settle();
+        const id = pending.id();
+
+        const inFlight = deferred();
+        bg.broadcastTransaction.mockReturnValue(inFlight.promise);
+        const first = bg.send(
+            {
+                type: "AUTISTMASK_TX_RESPONSE",
+                id,
+                approved: true,
+                rawSignedTx: await signedAtNonce(7),
+            },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
+        return { bg, pending, id, inFlight, first };
+    }
+
+    test("an approve on the port does not settle it", async () => {
+        const { bg, pending, id, inFlight, first } = await txMidBroadcast();
+
+        bg.connectApproval(id).decide(true, false);
+        await settle();
+        expect(pending.result()).toBeNull();
+
+        inFlight.resolve({ hash: "0xfeed" });
+        await settle();
+        expect(pending.result()).toEqual({ result: "0xfeed" });
+        expect(first.sendResponse).toHaveBeenCalledWith({ txHash: "0xfeed" });
+    });
+
+    test("a reject on the port does not settle it", async () => {
+        const { bg, pending, id, inFlight, first } = await txMidBroadcast();
+
+        bg.connectApproval(id).decide(false, false);
+        await settle();
+        expect(pending.result()).toBeNull();
+
+        inFlight.resolve({ hash: "0xfeed" });
+        await settle();
+        expect(pending.result()).toEqual({ result: "0xfeed" });
+        expect(first.sendResponse).toHaveBeenCalledWith({ txHash: "0xfeed" });
+    });
+
+    test("a port disconnect does not settle it", async () => {
+        const { bg, pending, id, inFlight, first } = await txMidBroadcast();
+
+        bg.connectApproval(id).disconnect();
+        await settle();
+        expect(pending.result()).toBeNull();
+
+        inFlight.resolve({ hash: "0xfeed" });
+        await settle();
+        expect(pending.result()).toEqual({ result: "0xfeed" });
+        expect(first.sendResponse).toHaveBeenCalledWith({ txHash: "0xfeed" });
+    });
+});
+
+// AUTISTMASK_TX_RESPONSE signs and broadcasts a transaction, so it is honoured
+// only for a transaction approval. A reject shaped as this message used to
+// retire a sign or connection approval outright, and an approve carrying a
+// signed artifact used to run the broadcast path against an approval that names
+// no transaction, failing closed only by throwing deeper in.
+describe("a transaction response is honoured only for a transaction approval", () => {
+    test("a reject does not retire a sign approval", async () => {
+        const bg = loadBackground();
+        const pending = bg.requestSign();
+        await settle();
+        const id = pending.id();
+
+        bg.send(
+            { type: "AUTISTMASK_TX_RESPONSE", id, approved: false },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(pending.result()).toBeNull();
+
+        // Still live: its own reject settles it.
+        bg.send(
+            { type: "AUTISTMASK_SIGN_RESPONSE", id, approved: false },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(pending.result()).toEqual({
+            error: { code: 4001, message: "User rejected the request." },
+        });
+    });
+
+    test("a reject does not retire a connection approval", async () => {
+        const bg = loadBackground({ actionPopup: true });
+        const pending = bg.requestSite();
+        await settle();
+        const id = pending.id();
+
+        bg.send(
+            { type: "AUTISTMASK_TX_RESPONSE", id, approved: false },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(pending.result()).toBeNull();
+
+        // Still live: the port that owns it connects the site.
+        const port = bg.connectApproval(id);
+        port.decide(true, false);
+        port.disconnect();
+        await settle();
+        expect(pending.result()).toEqual({ result: [signer.address] });
+    });
+
+    test("an approve carrying a signed transaction never broadcasts against a sign approval", async () => {
+        const bg = loadBackground();
+        const pending = bg.requestSign();
+        await settle();
+        const id = pending.id();
+
+        bg.send(
+            {
+                type: "AUTISTMASK_TX_RESPONSE",
+                id,
+                approved: true,
+                rawSignedTx: await signedAtNonce(7),
+            },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(bg.broadcastTransaction).not.toHaveBeenCalled();
+        expect(pending.result()).toBeNull();
+    });
+});
+
 // A handler that throws must still answer. `sendResponse` is the only thing
 // that settles the page's window.ethereum.request() promise, so a throw that
 // escapes a handler leaves that promise pending forever — no error, no
@@ -0,0 +1,100 @@
+// The wallet's OWN send path enforces the same combined fee bound the dApp
+// path does (https://git.eeqj.de/sneak/AutistMask/issues/399).
+//
+// The send in src/popup/views/confirmTx.js pins no fee fields, so ethers fills
+// maxFeePerGas and the gas limit from whatever the configured RPC node
+// answers. Nothing bounded that: a hostile node could report a fee whose
+// product with the gas limit is thousands of ETH, and it would be both
+// displayed and signed. populateVerifyAndSend() populates the transaction and
+// runs assertWithinCeilings() on the populated fees before signing, so an
+// over-bound send is refused before anything is broadcast.
+//
+// The check is driven here with a fake connected signer rather than a real
+// one: populateTransaction() returns the fees the node would have produced,
+// and sendTransaction() records whether the send actually happened. The real
+// DOM path around it — reading the fee error into the reserved errors box — is
+// covered by the Chrome e2e suite.
+
+globalThis.chrome = {
+    storage: { local: { get: async () => ({}), set: async () => {} } },
+};
+
+global.fetch = jest.fn(() => {
+    throw new Error("tests must not perform network requests");
+});
+
+const { populateVerifyAndSend } = require("../src/popup/views/confirmTx");
+const {
+    MAX_FEE_PER_GAS,
+    MAX_TOTAL_FEE,
+} = require("../src/shared/approvalVerify");
+
+const RECIPIENT = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+
+// A signer whose populateTransaction() fills in the fees a node quoted and
+// whose sendTransaction() records the call, so a test can assert whether the
+// send was reached at all.
+function fakeSigner(fees) {
+    const sent = [];
+    return {
+        sent,
+        populateTransaction: async (request) => ({
+            ...request,
+            from: RECIPIENT,
+            nonce: 0,
+            type: 2,
+            chainId: 1n,
+            gasLimit: fees.gasLimit,
+            maxFeePerGas: fees.maxFeePerGas,
+            maxPriorityFeePerGas: 1000000000n,
+        }),
+        sendTransaction: async (tx) => {
+            sent.push(tx);
+            return { hash: "0xabc" };
+        },
+    };
+}
+
+const ETH_SEND = { token: "ETH", to: RECIPIENT, amount: "1.0" };
+
+describe("populateVerifyAndSend enforces the combined fee bound", () => {
+    // A gas limit and a fee that are each under their own field ceiling, but
+    // multiply to about 3,000 ETH — the combination the per-field ceilings
+    // cannot see.
+    const OVER = { gasLimit: 30000000n, maxFeePerGas: MAX_FEE_PER_GAS };
+
+    test("each field is under its ceiling but the product is over the bound", () => {
+        expect(OVER.maxFeePerGas).toBeLessThanOrEqual(MAX_FEE_PER_GAS);
+        expect(OVER.gasLimit * OVER.maxFeePerGas).toBeGreaterThan(
+            MAX_TOTAL_FEE,
+        );
+    });
+
+    test("refuses an over-bound send without broadcasting it", async () => {
+        const signer = fakeSigner(OVER);
+        let thrown;
+        try {
+            await populateVerifyAndSend(signer, ETH_SEND);
+        } catch (e) {
+            thrown = e;
+        }
+        expect(thrown).toBeDefined();
+        expect(thrown.approvalMismatch).toBe(true);
+        expect(thrown.message).toMatch(/^[A-Z].*\.$/);
+        expect(thrown.message).toContain("3000.0 ETH");
+        expect(thrown.message).toContain("1.0 ETH");
+        // The one guarantee that matters: nothing was signed or sent.
+        expect(signer.sent).toHaveLength(0);
+    });
+
+    test("broadcasts a send whose product is just under the bound", async () => {
+        // 21,000 gas at 40 gwei is 0.00084 ETH — an ordinary send.
+        const under = { gasLimit: 21000n, maxFeePerGas: 40000000000n };
+        expect(under.gasLimit * under.maxFeePerGas).toBeLessThan(MAX_TOTAL_FEE);
+        const signer = fakeSigner(under);
+        const tx = await populateVerifyAndSend(signer, ETH_SEND);
+        expect(tx.hash).toBe("0xabc");
+        expect(signer.sent).toHaveLength(1);
+        expect(signer.sent[0].gasLimit).toBe(under.gasLimit);
+    });
+});
@@ -0,0 +1,59 @@
+// Tests for the debug/testnet banner (issue #375).
+//
+// On a testnet the banner is raised even in a release build, but it must not
+// append the active view's internal id: the user should see "[TESTNET]", never
+// "[TESTNET] (approve-tx)". The suffix is gated on the compile-time DEBUG
+// constant, which is false in a plain test load, so this drives exactly the
+// text a shipped build renders. Revert the gate to the old unconditional
+// suffix and this fails.
+//
+// The banner is created on demand by updateDebugBanner(); the document stub
+// records what it prepends so the assertion can read the resulting text.
+
+function makeBanner() {
+    return {
+        id: "",
+        textContent: "",
+        style: { cssText: "" },
+        remove() {},
+    };
+}
+
+function makeDocument() {
+    let banner = null;
+    return {
+        getElementById(id) {
+            return id === "debug-banner" ? banner : null;
+        },
+        createElement: () => makeBanner(),
+        body: {
+            prepend(node) {
+                banner = node;
+            },
+        },
+    };
+}
+
+function load() {
+    jest.resetModules();
+    globalThis.chrome = {
+        storage: { local: { get: async () => ({}), set: async () => {} } },
+    };
+    globalThis.document = makeDocument();
+    const helpers = require("../src/popup/views/helpers");
+    const { state } = require("../src/shared/state");
+    return { helpers, state };
+}
+
+describe("the release banner on a testnet", () => {
+    test("carries no internal view id", () => {
+        const { helpers, state } = load();
+        state.networkId = "sepolia";
+
+        helpers.updateDebugBanner("approve-tx");
+
+        expect(
+            globalThis.document.getElementById("debug-banner").textContent,
+        ).toBe("[TESTNET]");
+    });
+});
@@ -172,6 +172,15 @@ async function openLostPassword(deleteWallet, walletIdx) {
    await click("btn-delete-wallet-lost-password");
 }

+// Delete a wallet through the password route: open its confirm screen,
+// enter the password, and confirm. The vault is mocked, so the password
+// text itself is irrelevant — decryptWithPassword decides pass or fail.
+async function deleteWithPassword(deleteWallet, walletIdx) {
+    deleteWallet.show(walletIdx);
+    node("delete-wallet-password").value = "any password";
+    await click("btn-delete-wallet-confirm");
+}
+
 // ------------------------------------------------------------ tests

 // The stub is what every persistence assertion below rests on, so its one
@@ -456,15 +465,21 @@ describe("what the screen leaves behind", () => {
        );
    });

-    // Left mid-delete, the screen has to come back usable.
-    test("the confirm button is re-enabled on the way out", async () => {
-        const { helpers, deleteWallet } = load();
+    // Both routes now re-enable through finishDelete(), not their leave
+    // hooks, so the button comes back live once a delete completes.
+    test("the confirm button is re-enabled after a delete", async () => {
+        const { deleteWallet } = load();
        await openLostPassword(deleteWallet, 1);

-        node("btn-delete-wallet-lost-confirm").disabled = true;
-        helpers.showView("settings");
+        node("delete-wallet-lost-name-input").value = "Wallet 2";
+        await click("btn-delete-wallet-lost-confirm");

        expect(node("btn-delete-wallet-lost-confirm").disabled).toBe(false);
+        expect(
+            node("btn-delete-wallet-lost-confirm").classList.contains(
+                "text-muted",
+            ),
+        ).toBe(false);
    });

    // A wallet name is not a secret, so the screen is excluded for the
@@ -475,3 +490,48 @@ describe("what the screen leaves behind", () => {
        expect(RESTORABLE_VIEWS.has("delete-wallet-confirm")).toBe(false);
    });
 });
+
+// The password route is the pre-existing bug this file's fix addresses:
+// its Confirm Delete button was disabled before the decrypt and never
+// re-enabled on success, so a second delete in the same popup session
+// found a dead button. Now both routes re-enable through finishDelete().
+//
+// Against head these tests fail: with the re-enable absent, the button
+// stays disabled after the first delete, so the disabled assertions read
+// true where they expect false.
+describe("the password route's confirm button", () => {
+    test("is re-enabled after a successful delete", async () => {
+        const { deleteWallet, vault } = load();
+        vault.decryptWithPassword.mockResolvedValue();
+
+        await deleteWithPassword(deleteWallet, 1);
+
+        expect(node("btn-delete-wallet-confirm").disabled).toBe(false);
+        expect(
+            node("btn-delete-wallet-confirm").classList.contains("text-muted"),
+        ).toBe(false);
+    });
+
+    // The reported symptom: delete one wallet, then open Delete Wallet for
+    // a second one without reopening the popup. The button must be live on
+    // that second visit, and the second delete must actually persist.
+    test("a second delete works in the same popup session", async () => {
+        const { deleteWallet, vault, storage } = load();
+        vault.decryptWithPassword.mockResolvedValue();
+
+        await deleteWithPassword(deleteWallet, 1);
+
+        // Wallet 2 is gone; the list is now [Wallet 1, Wallet 3]. Opening
+        // the confirm screen for the wallet now at index 1 (Wallet 3) must
+        // find its button live, not the dead one the first delete left.
+        deleteWallet.show(1);
+        expect(node("btn-delete-wallet-confirm").disabled).toBe(false);
+
+        node("delete-wallet-password").value = "any password";
+        await click("btn-delete-wallet-confirm");
+
+        expect((await persistedWallets(storage)).map((w) => w.name)).toEqual([
+            "Wallet 1",
+        ]);
+    });
+});
@@ -372,10 +372,10 @@ step("the loopback dApp page gets the real inpage provider", async (env) => {
        STEP_TIMEOUT_MS,
    );

-    // EIP-6963, asked of the provider itself. The announcement carries the
-    // uuid src/content/index.js reads out of extension storage — call site 1
-    // in the issue — and it has to name this extension and hand back the very
-    // object on window.ethereum.
+    // EIP-6963, asked of the provider itself. The announcement carries a
+    // UUIDv4 inpage.js generates fresh for this page load (nothing persists
+    // it — see issue #398) and has to name this extension and hand back the
+    // very object on window.ethereum.
    const announced = await d.executeAsync(
        `const done = arguments[arguments.length - 1];
         const onAnnounce = (e) => {
@@ -402,7 +402,7 @@ step("the loopback dApp page gets the real inpage provider", async (env) => {
    );
    assert(
        typeof announced.uuid === "string" && announced.uuid.length === 36,
-        "the announcement carries no stored provider uuid: " +
+        "the announcement carries no provider uuid: " +
            JSON.stringify(announced.uuid),
    );

@@ -1525,6 +1525,7 @@ async function goToConfirm(page, { token, balance, amount }) {
    await page.fill("#send-amount", amount);
    await page.click("#btn-send-review");
    await visible(page, "#view-confirm-tx");
+    await assertAddressesFit(page, "the confirmation screen");
 }

 // A balance as the main view renders it: balanceLinesForAddress() writes
@@ -3262,6 +3263,8 @@ test("eth_sendTransaction signs the approved transaction and broadcasts it (#183
            JSON.stringify(screen.data),
    );

+    await assertAddressesFit(popup, "the dApp transaction prompt");
+
    const broadcastBefore = env.routeOpts.broadcastTransactions.length;
    await popup.fill("#approve-tx-password", PASSWORD);
    await popup.click("#btn-approve-tx");
@@ -3425,6 +3428,206 @@ test("the password never crossed either boundary in this section (#183)", async
    await env.dapp.close();
 });

+// ------------------------------------------- address layout (#380)
+//
+// "addresses should never wrap in the common views. this doesn't mean to
+// just change the css, but update the layout itself so the untruncated
+// addresses are shown in full and don't mess up the layout."
+//
+// Every one of these questions is about glyph advances and the width of
+// the box an address landed in, and nothing in the markup answers any of
+// them: a row can hold `white-space: nowrap` and still be too narrow, and
+// the popup's own `overflow-x-hidden` would then hide the evidence by
+// clipping the tail. So they are measured in a real Chromium, on the real
+// rendered views, one assertion per property #380 names:
+//
+//   - the whole address is there (42 characters, no ellipsis)
+//   - it occupies exactly one line box
+//   - it fits its row, so the overflow-x escape hatch never engages
+//   - its row ends inside the popup's content box
+//   - and the document itself does not scroll sideways
+//
+// The narrowest containers the popup has are covered here — the
+// transaction detail wells (`bg-well p-3 mx-1`) and the token contract
+// well — so the wider ones cannot fail while these pass.
+
+// Everything on screen that carries an address, measured in one pass.
+// Views other than the current one are display:none and measure zero, so
+// filtering on width leaves exactly what a user can see right now.
+function addressRowReport(page) {
+    return page.evaluate(() => {
+        const app = document.getElementById("app");
+        const appRight = app.getBoundingClientRect().right;
+        const rows = [];
+        for (const el of document.querySelectorAll(".am-address")) {
+            const box = el.getBoundingClientRect();
+            if (box.width === 0) continue;
+            // Line boxes are counted off the inline content, because the
+            // element's own rect is one box whether the text inside it
+            // wrapped or not. A Range yields a rect per contained node as
+            // well as per line, so it is the distinct tops that count:
+            // a copyable span and the text inside it share one.
+            const range = document.createRange();
+            range.selectNodeContents(el);
+            const tops = new Set(
+                Array.from(range.getClientRects()).map((r) =>
+                    Math.round(r.top),
+                ),
+            );
+            rows.push({
+                text: el.innerText.trim(),
+                lineBoxes: tops.size,
+                overflow: el.scrollWidth - el.clientWidth,
+                overhang: Math.round(box.right - appRight),
+            });
+        }
+        return {
+            rows,
+            pageOverflow:
+                document.documentElement.scrollWidth -
+                document.documentElement.clientWidth,
+        };
+    });
+}
+
+async function assertAddressesFit(page, where) {
+    const report = await addressRowReport(page);
+    assert(
+        report.rows.length > 0,
+        where + ": no address rows were rendered, so nothing was measured",
+    );
+    for (const row of report.rows) {
+        assert(
+            /^0x[0-9a-fA-F]{40}$/.test(row.text),
+            where +
+                ": the address is not shown whole: " +
+                JSON.stringify(row.text),
+        );
+        assert(
+            row.lineBoxes === 1,
+            where +
+                ": " +
+                row.text +
+                " wrapped onto " +
+                row.lineBoxes +
+                " lines",
+        );
+        assert(
+            row.overflow <= 1,
+            where +
+                ": " +
+                row.text +
+                " is " +
+                row.overflow +
+                "px wider than the row holding it",
+        );
+        assert(
+            row.overhang <= 1,
+            where +
+                ": " +
+                row.text +
+                " reaches " +
+                row.overhang +
+                "px past the popup's content box",
+        );
+    }
+    assert(
+        report.pageOverflow <= 0,
+        where + ": the popup scrolls sideways by " + report.pageOverflow + "px",
+    );
+    return report.rows.length;
+}
+
+// Back to Home from wherever the suite above finished, without assuming
+// which screen that was. Every screen the popup can rest on has a Back
+// button, and Home has none, so unwinding until Home shows is the one
+// route that does not depend on the order of the tests before this point.
+async function unwindToHome(page) {
+    for (let i = 0; i < 12; i++) {
+        if (await page.isVisible("#view-main")) return;
+        const back = page
+            .locator(".view:not(.hidden) button", { hasText: "Back" })
+            .first();
+        if ((await back.count()) === 0) break;
+        await back.click();
+        await page.waitForTimeout(150);
+    }
+    await visible(page, "#view-main");
+}
+
+// The reproduction from the issue: a wallet holding more than one address.
+// Every address in the list is a full 42 characters competing with the
+// [info] and [x] controls for one row's width, which is the state the
+// wallet view was reported wrapping in.
+test("a wallet with two addresses lists both in full, unwrapped (#380)", async (env) => {
+    await unwindToHome(env.page);
+
+    const before = await env.page
+        .locator("#wallet-list .btn-addr-info")
+        .count();
+    await env.page.locator("#wallet-list .btn-add-address").first().click();
+    await env.page.waitForFunction(
+        (n) =>
+            document.querySelectorAll("#wallet-list .btn-addr-info").length > n,
+        before,
+        { timeout: 60000 },
+    );
+
+    const shown = await assertAddressesFit(env.page, "the wallet list");
+    assert(
+        shown >= before + 1,
+        "the wallet list measured " +
+            shown +
+            " addresses, fewer than the " +
+            (before + 1) +
+            " it now holds",
+    );
+
+    // The [x] control only exists on a wallet holding more than one
+    // address, so its presence is also the proof the second one landed.
+    const removable = await env.page
+        .locator("#wallet-list .btn-remove-address")
+        .count();
+    assert(removable > 0, "the second address did not reach the wallet list");
+});
+
+test("every common view shows its addresses in full on one line (#380)", async (env) => {
+    await unwindToHome(env.page);
+    await assertAddressesFit(env.page, "Home");
+
+    await env.page.locator("#wallet-list .btn-addr-info").first().click();
+    await visible(env.page, "#view-address");
+    await visible(env.page, "#tx-list .tx-row");
+    await assertAddressesFit(env.page, "the address screen");
+
+    await env.page.click("#btn-receive");
+    await visible(env.page, "#view-receive");
+    await assertAddressesFit(env.page, "the receive screen");
+    await env.page.click("#btn-receive-back");
+    await visible(env.page, "#view-address");
+
+    await env.page.click("#btn-send");
+    await visible(env.page, "#view-send");
+    await assertAddressesFit(env.page, "the send screen");
+    await env.page.click("#btn-send-back");
+    await visible(env.page, "#view-address");
+
+    // The transaction detail screen carries the narrowest address rows in
+    // the popup: its fields sit inside a well that takes another 24px of
+    // padding and 8px of margin off the content width, and the token
+    // contract row there is narrower still.
+    await env.page.locator("#address-balances .balance-row").first().click();
+    await visible(env.page, "#view-address-token");
+    await assertAddressesFit(env.page, "the token screen");
+    await env.page.click("#btn-address-token-back");
+    await visible(env.page, "#view-address");
+
+    await env.page.locator("#tx-list .tx-row").first().click();
+    await visible(env.page, "#view-transaction");
+    await visible(env.page, "#tx-detail-token-contract-section");
+    await assertAddressesFit(env.page, "the transaction detail screen");
+});
+
 // ---------------------------------------------------------------- runner

 async function main() {
@@ -89,19 +89,28 @@ describe("chrome extension identity", () => {

    // The private half is a credential. It has never been in this repo and no
    // target generates one into the working tree; this fails loudly if that
-    // ever changes, because a committed .pem is a key anyone can sign a CRX
-    // with under this extension's id.
+    // ever changes, because a committed private key is one anyone can sign a
+    // CRX with under this extension's id.
+    //
+    // Matched by CONTENT, not by filename: a key committed as notes.txt or with
+    // no extension carries the same risk as one named key.pem, and a
+    // filename-only check waves it through. The PEM header a private key opens
+    // with is the signature searched for. The pattern does not trip on its own
+    // source: the bracket-expression characters between the two anchors are not
+    // in the character class, so this file is not a match for it.
+    const PRIVATE_KEY_HEADER = /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----/;
    test("no private key is committed anywhere in the tree", () => {
+        const root = path.join(__dirname, "..");
        const tracked = require("child_process")
-            .execSync("git ls-files", {
-                cwd: path.join(__dirname, ".."),
-                encoding: "utf8",
-            })
+            .execSync("git ls-files", { cwd: root, encoding: "utf8" })
            .split("\n")
            .filter(Boolean);
-        expect(tracked.filter((f) => /\.(pem|key|p12|pfx)$/i.test(f))).toEqual(
-            [],
+        const offenders = tracked.filter((f) =>
+            PRIVATE_KEY_HEADER.test(
+                fs.readFileSync(path.join(root, f), "latin1"),
+            ),
        );
+        expect(offenders).toEqual([]);
    });
 });

@@ -0,0 +1,283 @@
+// What the balance fetcher stores when the block explorer reports no decimals
+// for a token, and what the approval screens then display.
+//
+// https://git.eeqj.de/sneak/AutistMask/issues/349: `fetchTokenBalances()` did
+// `parseInt(item.token.decimals || "18", 10)` BEFORE writing the row, so a
+// token whose `decimals()` reverts — and which the explorer therefore reports
+// no scale for — was stored with a fabricated 18. Nothing downstream could
+// tell that from a real 18.
+//
+// That matters because it is upstream of two refusals that were already built
+// and already merged. https://git.eeqj.de/sneak/AutistMask/issues/306 made the
+// ERC-20 amount line resolve the real scale or refuse to format, and
+// https://git.eeqj.de/sneak/AutistMask/issues/340 did the same for the swap
+// lines. Both read this stored value as an authoritative source, so the guess
+// walked straight past them: the refusal was intact and simply never fired.
+//
+// So these tests run a real explorer response through the real fetcher and
+// assert on the real approval screens. A test that hand-writes `decimals: null`
+// onto state would pass on the broken build, because the fabrication is in the
+// writer, not the readers.
+
+jest.mock("../src/shared/log", () => ({
+    log: {
+        debugf: () => {},
+        infof: () => {},
+        warnf: () => {},
+        errorf: () => {},
+    },
+    debugFetch: jest.fn(),
+    setRuntimeDebug: () => {},
+    isDebug: () => false,
+}));
+
+global.fetch = jest.fn(() => {
+    throw new Error("tests must not perform network requests");
+});
+
+const { makeStorageStub } = require("./support/storageStub");
+global.chrome = { storage: makeStorageStub() };
+
+const { AbiCoder, Interface } = require("ethers");
+const { ERC20_ABI } = require("../src/shared/constants");
+const { fetchTokenBalances } = require("../src/shared/balances");
+const { debugFetch } = require("../src/shared/log");
+const { state } = require("../src/shared/state");
+const { unknownDecimalsAmount } = require("../src/shared/approvalAmount");
+const { decodeCalldata } = require("../src/popup/views/approval");
+const { TOKEN_BY_ADDRESS } = require("../src/shared/tokenList");
+
+const HOLDER = "0x" + "a".repeat(40);
+const BLOCKSCOUT = "https://blockscout.example/api/v2";
+const ROUTER = "0x66a9893cc07d91d95644aedd05d03f95e1dba8af";
+const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
+const SPENDER = "0x1111111111111111111111111111111111111111";
+// Outside the bundled list and untracked, so the explorer is the only source
+// of a scale for it — which is the case the fabrication was hiding.
+const NOVEL = "0xE2E0000000000000000000000000000000000E2e";
+// In the bundled list, at 18 decimals, for the other side of a swap.
+const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+
+// The holding the explorer reports, in base units. Large enough that it does
+// not round to zero even when divided by 10^18, which is what makes it the
+// case the laundering actually REACHED: a smaller holding formatted at the
+// fabricated 18 comes out "0.0", the balance list drops the row as dust, and
+// the approval screens then find no source for the scale and refuse anyway —
+// for the wrong reason, and only by luck.
+const HOLDING = 5000000000000000000n;
+
+// The amount in the dApp's calldata, which is a separate number from the
+// holding. 1,000.00 of a 6-decimal token; formatted at the fabricated 18 it
+// reads 0.000000001, and at a real scale of 0 it reads 1000000000.
+const THOUSAND_AT_SIX = 1000000000n;
+const HALF_WETH = 500000000000000000n;
+
+const erc20Iface = new Interface(ERC20_ABI);
+const coder = AbiCoder.defaultAbiCoder();
+const routerIface = new Interface([
+    "function execute(bytes commands, bytes[] inputs, uint256 deadline)",
+]);
+
+// One Blockscout token-balances row. `token` is spread last so a test can
+// override or blank a field; the base row carries no `decimals` at all, which
+// is exactly what a token whose decimals() reverts produces.
+function row(token = {}, value = HOLDING) {
+    return {
+        value: String(value),
+        token: {
+            type: "ERC-20",
+            address_hash: NOVEL,
+            symbol: "NOVEL",
+            name: "Novel Token",
+            // Well clear of the balance list's own spam floor, so the row is
+            // admitted on its holder count alone: neither the bundled list nor
+            // a tracked entry can supply a scale for it.
+            holders_count: "50000",
+            ...token,
+        },
+    };
+}
+
+function respondWith(items) {
+    debugFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        statusText: "OK",
+        json: async () => items,
+    }));
+}
+
+// Fetch and place the result exactly where refreshBalances() places it, so the
+// approval screens read what a real refresh would have left on state.
+async function fetchOnto(items, trackedTokens = []) {
+    respondWith(items);
+    const balances = await fetchTokenBalances(
+        HOLDER,
+        BLOCKSCOUT,
+        trackedTokens,
+    );
+    state.trackedTokens = trackedTokens;
+    state.wallets = [
+        {
+            name: "Wallet 1",
+            addresses: [
+                { address: HOLDER, balance: "1.0", tokenBalances: balances },
+            ],
+        },
+    ];
+    return balances;
+}
+
+// The ERC-20 approval screen's Amount line, and the swap decoder's.
+function erc20AmountLine(data, tokenAddress) {
+    return decodeCalldata(data, tokenAddress).details.find(
+        (d) => d.label === "Amount",
+    ).value;
+}
+
+function swapAmountLine(data) {
+    return decodeCalldata(data, ROUTER).details.find(
+        (d) => d.label === "Amount",
+    ).value;
+}
+
+function transferData(amount) {
+    return erc20Iface.encodeFunctionData("transfer", [RECIPIENT, amount]);
+}
+
+function approveData(amount) {
+    return erc20Iface.encodeFunctionData("approve", [SPENDER, amount]);
+}
+
+function swapData(tokenIn, amountIn, tokenOut, amountOutMin) {
+    const input = coder.encode(
+        ["address", "uint256", "uint256", "address[]", "bool"],
+        [RECIPIENT, amountIn, amountOutMin, [tokenIn, tokenOut], true],
+    );
+    return routerIface.encodeFunctionData("execute", [
+        "0x08",
+        [input],
+        9999999999n,
+    ]);
+}
+
+beforeEach(() => {
+    debugFetch.mockReset();
+    state.trackedTokens = [];
+    state.wallets = [];
+});
+
+describe("what fetchTokenBalances stores for an absent scale", () => {
+    test("the token is not in the bundled list, so the explorer is the only source", () => {
+        expect(TOKEN_BY_ADDRESS.has(NOVEL.toLowerCase())).toBe(false);
+    });
+
+    test("an absent decimals is stored as null, not as 18", async () => {
+        const balances = await fetchOnto([row()]);
+        expect(balances).toHaveLength(1);
+        expect(balances[0].decimals).toBeNull();
+    });
+
+    test("an explicit null decimals is stored as null too", async () => {
+        const balances = await fetchOnto([row({ decimals: null })]);
+        expect(balances[0].decimals).toBeNull();
+    });
+
+    // The same explorer row twice, differing only in whether it reports a
+    // scale of 18. Before the fix both stored 18 and no reader could tell
+    // which one had actually been reported.
+    test("a real 18 is stored as 18, and so is distinguishable from absent", async () => {
+        const real = await fetchOnto([row({ decimals: "18" })]);
+        expect(real[0].decimals).toBe(18);
+        expect(real[0].balance).toBe("5.0");
+        const absent = await fetchOnto([row()]);
+        expect(absent[0].decimals).toBeNull();
+        expect(real[0].decimals).not.toBe(absent[0].decimals);
+    });
+
+    // The falsy-collapse trap of
+    // https://git.eeqj.de/sneak/AutistMask/issues/246. `decimals || "18"` reads
+    // a real scale of zero as absent and then as eighteen, which is eighteen
+    // orders of magnitude of error in the direction that displays as nothing.
+    test("a real scale of zero is stored as zero, not collapsed", async () => {
+        for (const reported of ["0", 0]) {
+            const balances = await fetchOnto([row({ decimals: reported })]);
+            expect(balances[0].decimals).toBe(0);
+            expect(balances[0].balance).toBe("5000000000000000000.0");
+        }
+    });
+
+    test("no quantity is stated for a holding whose scale is unknown", async () => {
+        const balances = await fetchOnto([row()]);
+        // Not "0.0": the holding is real and nonzero, and a zero here is the
+        // same lie the approval screens refuse to tell.
+        expect(balances[0].balance).toBeNull();
+    });
+
+    // Zero base units is zero tokens at every scale, so this filter never
+    // needed a scale in the first place and does not acquire one now.
+    test("a holding of zero base units is still dropped without a scale", async () => {
+        expect(await fetchOnto([row({}, 0n)])).toEqual([]);
+    });
+
+    test("the bundled list still supplies a quantity the explorer omitted", async () => {
+        const balances = await fetchOnto([
+            row({ address_hash: WETH, symbol: "WETH" }),
+        ]);
+        // The stored decimals stay the explorer's own answer — absent. Copying
+        // another source in here would make explorerDecimals()'s disagreement
+        // check compare something other than explorer values.
+        expect(balances[0].decimals).toBeNull();
+        // The displayed quantity still comes out right, because the bundled
+        // list knows this token's scale and outranks the explorer anyway.
+        expect(balances[0].balance).toBe("5.0");
+    });
+});
+
+describe("the ERC-20 approval line reaches its refusal", () => {
+    test("a transfer of a token the explorer gave no scale for is not formatted", async () => {
+        await fetchOnto([row()]);
+        const line = erc20AmountLine(transferData(THOUSAND_AT_SIX), NOVEL);
+        expect(line).toBe(unknownDecimalsAmount(THOUSAND_AT_SIX));
+        // The defect: a fabricated 18 renders this as 0.000000001, a quantity,
+        // and a wrong one.
+        expect(line).not.toMatch(/^0\./);
+    });
+
+    test("an approve of the same token is not formatted either", async () => {
+        await fetchOnto([row()]);
+        const line = erc20AmountLine(approveData(THOUSAND_AT_SIX), NOVEL);
+        expect(line).toBe(unknownDecimalsAmount(THOUSAND_AT_SIX));
+        expect(line).not.toMatch(/^0\./);
+    });
+
+    test("a scale the explorer did report still formats", async () => {
+        await fetchOnto([row({ decimals: "6" })]);
+        // The same explorer entry now also names the token (issue #323).
+        expect(erc20AmountLine(transferData(THOUSAND_AT_SIX), NOVEL)).toBe(
+            "1000.0000 NOVEL",
+        );
+    });
+});
+
+describe("the swap approval line reaches its refusal", () => {
+    test("a swap of a token the explorer gave no scale for is not formatted", async () => {
+        await fetchOnto([row()]);
+        const line = swapAmountLine(
+            swapData(NOVEL, THOUSAND_AT_SIX, WETH, HALF_WETH),
+        );
+        expect(line).toBe(unknownDecimalsAmount(THOUSAND_AT_SIX));
+        expect(line).not.toMatch(/^0\./);
+    });
+
+    test("a scale the explorer did report still formats", async () => {
+        await fetchOnto([row({ decimals: "6" })]);
+        expect(
+            swapAmountLine(swapData(NOVEL, THOUSAND_AT_SIX, WETH, HALF_WETH)),
+        ).toBe("1000.0000 NOVEL");
+    });
+});
+
+test("no test in this file performed a network request", () => {
+    expect(global.fetch).not.toHaveBeenCalled();
+});
@@ -0,0 +1,103 @@
+// The EIP-6963 provider UUID inpage.js announces (src/content/inpage.js).
+//
+// The bug this pins down (issue #398): the UUID used to be generated once,
+// persisted in extension storage, and announced verbatim to every page on
+// every load and across browser restarts, so any site — connected or not —
+// could read a stable cross-site, cross-session identifier for the install.
+// EIP-6963 wants a fresh UUIDv4 per announcement instead. The fix generates
+// it per page load and stores nothing.
+//
+// inpage.js is a bare IIFE injected into the page's JS context, not a module;
+// see tests/inpageErrors.test.js for why it is evaluated against a stub window
+// rather than imported. Here the stub captures the CustomEvent that carries
+// the announcement, so the UUID this file reads is the one a real dApp's
+// eip6963:announceProvider listener would see.
+
+const fs = require("fs");
+const path = require("path");
+const { webcrypto } = require("crypto");
+
+const SOURCE = fs.readFileSync(
+    path.join(__dirname, "..", "src", "content", "inpage.js"),
+    "utf8",
+);
+
+const loadInto = new Function(
+    "window",
+    "self",
+    "crypto",
+    "Event",
+    "CustomEvent",
+    SOURCE,
+);
+
+class StubEvent {
+    constructor(type) {
+        this.type = type;
+    }
+}
+
+class StubCustomEvent extends StubEvent {
+    constructor(type, init) {
+        super(type);
+        this.detail = init && init.detail;
+    }
+}
+
+// Evaluate inpage.js once against a fresh stub window and return every UUID it
+// announced. A `requestProvider` event is dispatched too, so a re-announcement
+// within one load is observed as well as the announcement at load.
+function announcedUuids() {
+    const listeners = {};
+    const uuids = [];
+
+    const win = {
+        addEventListener(type, fn) {
+            (listeners[type] || (listeners[type] = [])).push(fn);
+        },
+        removeEventListener(type, fn) {
+            const fns = listeners[type];
+            if (!fns) return;
+            const i = fns.indexOf(fn);
+            if (i !== -1) fns.splice(i, 1);
+        },
+        postMessage() {},
+        dispatchEvent(event) {
+            if (event.type === "eip6963:announceProvider") {
+                uuids.push(event.detail.info.uuid);
+            }
+            for (const fn of (listeners[event.type] || []).slice()) fn(event);
+            return true;
+        },
+    };
+    win.window = win;
+
+    loadInto(win, win, webcrypto, StubEvent, StubCustomEvent);
+    win.dispatchEvent(new StubEvent("eip6963:requestProvider"));
+    return uuids;
+}
+
+const UUID_V4 =
+    /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+describe("the EIP-6963 provider UUID is fresh per page load", () => {
+    test("a load announces a UUIDv4, unprompted, with nothing delivered", () => {
+        const uuids = announcedUuids();
+        expect(uuids.length).toBeGreaterThan(0);
+        expect(uuids[0]).toMatch(UUID_V4);
+    });
+
+    test("every announcement within one load carries the same UUID", () => {
+        const uuids = announcedUuids();
+        expect(uuids.length).toBeGreaterThan(1);
+        expect(new Set(uuids).size).toBe(1);
+    });
+
+    test("two page loads announce different UUIDs", () => {
+        const first = announcedUuids()[0];
+        const second = announcedUuids()[0];
+        expect(first).toMatch(UUID_V4);
+        expect(second).toMatch(UUID_V4);
+        expect(second).not.toBe(first);
+    });
+});
@@ -47,6 +47,12 @@ const fs = require("fs");
 const path = require("path");

 const MANIFEST_DIR = path.join(__dirname, "..", "manifest");
+const ROOT = path.join(__dirname, "..");
+
+// The sizes both stores and both toolbars ask for.
+const EXPECTED_ICON_SIZES = ["16", "32", "48", "128"];
+
+const PNG_SIGNATURE = Buffer.from("89504e470d0a1a0a", "hex");

 const EXPECTED_DIRECTIVES = {
    "default-src": ["'self'"],
@@ -115,6 +121,51 @@ function assertPolicy(policy) {
    }
 }

+// The declared icons, in both manifests.
+//
+// Without an "icons" block a browser draws a generic puzzle piece in the
+// toolbar for this extension, which is both the first thing the user sees and
+// how a real extension is told apart from a look-alike. Declaring one is not
+// enough on its own: an entry naming a file that is not in the tree ships a
+// reference to nothing, so the referenced bytes are read here and required to
+// be a PNG of the size the entry claims. build.js copies these into each
+// browser directory, relative to it, and script/lib/package.js then refuses to
+// build an archive that does not contain everything the manifest names.
+function assertIcons(target) {
+    const icons = readManifest(target).icons;
+    expect(Object.keys(icons).sort()).toEqual(EXPECTED_ICON_SIZES.sort());
+    for (const size of EXPECTED_ICON_SIZES) {
+        const ref = icons[size];
+        expect([size, ref]).toEqual([size, `icons/icon${size}.png`]);
+
+        const bytes = fs.readFileSync(path.join(ROOT, ref));
+        expect(bytes.subarray(0, 8)).toEqual(PNG_SIGNATURE);
+        // IHDR width and height, at fixed offsets right after the signature
+        // and the chunk header.
+        expect([ref, bytes.readUInt32BE(16), bytes.readUInt32BE(20)]).toEqual([
+            ref,
+            Number(size),
+            Number(size),
+        ]);
+    }
+}
+
+describe("declared icons", () => {
+    test("chrome declares real icons at every size", () => {
+        assertIcons("chrome");
+    });
+
+    test("firefox declares real icons at every size", () => {
+        assertIcons("firefox");
+    });
+
+    test("both targets declare the same icons", () => {
+        expect(readManifest("firefox").icons).toEqual(
+            readManifest("chrome").icons,
+        );
+    });
+});
+
 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.
@@ -90,6 +90,26 @@ describe("archive self-containment", () => {
        );
    });

+    // Toolbar icons are the other file the manifest names and no bundler
+    // emits, so an archive built without them would carry a manifest whose
+    // "icons" resolve to nothing and a browser would fall back to a generic
+    // placeholder without saying so.
+    test("a manifest naming an icon that is not in the archive fails", () => {
+        const { members, read } = archiveOf({
+            "manifest.json": JSON.stringify({
+                ...MINIMAL_MANIFEST,
+                icons: { 16: "icons/icon16.png", 128: "icons/icon128.png" },
+            }),
+            "src/popup/index.html": "<html></html>",
+            "src/popup/index.js": "//",
+            "src/background/index.js": "//",
+            "icons/icon16.png": "PNG",
+        });
+        expect(() => checkSelfContained("chrome", members, read)).toThrow(
+            /would not be self-contained.*icons\/icon128\.png/s,
+        );
+    });
+
    test("an archive with no manifest.json at its root fails", () => {
        const { members, read } = archiveOf({ "src/popup/index.js": "//" });
        expect(() => checkSelfContained("chrome", members, read)).toThrow(
@@ -20,12 +20,56 @@
 //                  that no structural dereference of it is reachable from a
 //                  stored record — which cannot be argued, only driven, so the
 //                  proof is a boot of the REAL popup entry point over a stored
-//                  record carrying the hostile value.
+//                  record carrying the hostile value, ONTO EVERY RESTORABLE
+//                  VIEW. Home is not where this class of defect lives.
 //
-// Every row is driven through the boot regardless of kind, and a LOOSE row
-// must additionally prove it is loose: if someone floors the field and leaves
-// the row saying LOOSE, the "survives verbatim" assertion fails. A field added
-// to PERSISTED_FIELDS with no row fails the first test in the file.
+// Every row is driven through a boot regardless of kind, but only a LOOSE row
+// (or a row that sets `alsoSweep`) is swept across the restore path: that is
+// what declaring LOOSE costs. ENTRIES and SCALAR rows are proven by their
+// holds() instead, because a floored value is not hostile by the time a
+// renderer sees it. A LOOSE row must additionally prove it is loose: if
+// someone floors the field — even partially — and leaves the row saying LOOSE,
+// the "survives verbatim" assertion fails. A field added to PERSISTED_FIELDS
+// with no row fails the first test in the file.
+//
+// The sweep is what makes a LOOSE row falsifiable, so read how it is driven
+// before trusting it. A row the ROUTER reads (`routes`) gets its own boot per
+// view, because a hostile value in it legitimately changes which view renders.
+// Every other swept field is corrupted on the SAME boot, one boot per view per
+// slot, and that boot has to land on the view it stored — so a field that does
+// move the routing cannot hide in the crowd. Every swept field is driven at
+// BOTH POLARITIES: a value nothing in src/ writes is a wrong-typed one and so
+// always truthy, which leaves `if (!state.x) { state.y.deref() }` unentered on
+// the very boot that corrupts x. The last slot is the falsy one for that
+// reason, and a field that cannot be falsy after the floor says so in its row
+// and is proven so.
+//
+// READ THE CLAIM NARROWLY. What this file proves is: NO STRUCTURAL
+// DEREFERENCE ON THE CODE PATHS A WHOLLY-CORRUPTED PROFILE TAKES. That is not
+// every path a stored record takes, and the difference is the whole of what
+// this file does not cover:
+//
+//   - Only the values in the table, in the SLOT arrangement below: four value
+//     combinations per view, not the product of twelve fields. A dereference
+//     reached only under a pairing no slot produces is not driven at all.
+//   - Only what a stored record reaches by ITSELF. A view only forward
+//     navigation opens, and anything behind a click, is not driven.
+//   - Nothing about the paths a HEALTHY profile takes, which is most of the
+//     popup. This file is a floor under one defect class, not a proof about
+//     the renderers.
+//
+// Within that boundary it is unconditional: if one of these boots leaves the
+// popup unhealthy or off the view it stored, this file goes red — including
+// when it takes two corrupted fields at once, because the verdict is the
+// combined boot itself and the per-field re-boot below can only decorate the
+// message. That last part is the one thing an earlier version got wrong: it
+// asserted on the per-field list, so an observed dead popup that no single
+// field reproduced was reported green.
+//
+// Booting every field separately at every value would be several hundred boots
+// and most of the suite's budget; this is forty-four. Widening it further is
+// out of scope — proving no field is dereferenced on any reachable render path
+// is exhaustive verification of the popup, not a floor under a stored record.
 //
 // The three claims this replaced, all false, all caught here by construction:
 // rpcUrl reaching `new JsonRpcProvider()` (a synchronous throw, not a caught
@@ -61,12 +105,39 @@ const isIndexOrNull = (v) => v === null || (Number.isInteger(v) && v >= 0);
 const isTextOrNull = (v) => v === null || (isText(v) && v !== "");
 const everyEntry = (v, fn) => Array.isArray(v) && v.every(fn);

+// A row is SWEPT — driven onto every restorable view rather than only onto
+// Home — when its claim is that no restore path dereferences the field. That
+// is what LOOSE means. The two index rows opt in with `alsoSweep` although
+// they are floored, because the restore path is precisely why they gained a
+// floor and the sweep is the regression guard on it.
+const swept = (row) => row.kind === KIND.LOOSE || Boolean(row.alsoSweep);
+
+// Every value a swept row drives through a boot: the hostile set, plus the
+// falsy slot that gives the field its other polarity. `hostile` values are all
+// TRUTHY by nature — a value nothing in src/ writes is a wrong-typed one, and
+// wrong-typed values are objects, non-empty strings and non-zero numbers. A
+// field that is only ever truthy on the boot that corrupts it cannot falsify
+// `if (!state.x) { state.y.deref() }`, so the falsy slot is not optional.
+const sweptValues = (row) => [...row.hostile, ...(row.falsy || [])];
+
 // ------------------------------------------------------------------ the table
 //
 // `hostile` is values a stored record can carry that nothing in src/ ever
-// writes. Each one is driven through the floor AND through a real popup boot,
-// so keep the list short and pointed. `floorOnly` is extra values checked
-// against the floor alone, which is pure and free.
+// writes. Each one is driven through the floor AND through a real popup boot —
+// and, for a swept row, through one boot per restorable view — so keep the
+// list short and pointed. `floorOnly` is extra values checked against the
+// floor alone, which is pure and free. `hostileRestore` is extra values driven
+// through the restore path only, for a value that means nothing until a
+// particular branch's gate has let it past.
+//
+// `falsy` is the other POLARITY of a swept field, driven for the same reason.
+// It is not a value src/ never writes — for three of these fields it is the
+// DEFAULT_STATE default, which is the branch every ordinary install takes —
+// and that is the point: without it, a dereference behind `if (!state.x)` is
+// unreachable on the one boot that corrupts x. A swept row that cannot supply
+// one says `neverFalsy` instead, which is proven rather than asserted: every
+// falsy value stored under that field comes back TRUTHY from the floor, so no
+// `!state.x` branch is reachable from a stored record at all.

 const CONTRACT = [
    {
@@ -213,6 +284,14 @@ const CONTRACT = [
        hostile: ["map", "__proto__", { a: 1 }],
        floorOnly: ["length", "constructor", "toString", "0", -1, 1.5, true],
        holds: isIndexOrNull,
+        // SCALAR, and swept anyway: the restore path is precisely why this
+        // field gained a floor, so the sweep is the regression guard on it.
+        alsoSweep: true,
+        routes: true,
+        // A stale INTEGER index, which reaches the restore path by a different
+        // route from the prototype members above — falsy or out of range
+        // rather than truthy — and has to keep being the safe case.
+        hostileRestore: [{ value: "length" }, { value: 5 }],
    },
    {
        field: "selectedAddress",
@@ -220,24 +299,110 @@ const CONTRACT = [
        hostile: ["map", "__proto__", { a: 1 }],
        floorOnly: ["length", "constructor", "toString", "0", -1, 1.5, true],
        holds: isIndexOrNull,
+        alsoSweep: true,
+        routes: true,
+        hostileRestore: [{ value: 5 }],
    },
    {
        field: "currentView",
        kind: KIND.LOOSE,
+        routes: true,
        // Compared, and concatenated into the debug banner's textContent
        // (src/popup/views/helpers.js) with no gate in front of it, which
        // coerces. Nothing renders FROM it without RESTORABLE_VIEWS.has()
        // first, and Set.has() answers false for any value.
        hostile: [42, "no-such-view", { a: 1 }],
+        // `saved.currentView || null`: the falsy polarity is the popup landing
+        // on Home, which every boot in "booting onto Home" below also drives.
+        falsy: [""],
    },
    {
        field: "viewData",
        kind: KIND.LOOSE,
+        routes: true,
        // The container is taken verbatim; what makes its ENTRIES safe is the
-        // per-branch guard in src/popup/viewRouter.js. Driven over every
-        // restorable view in "a malformed viewData" below, which is the proof
-        // this row rests on.
-        hostile: [42, "notarecord", { a: 1 }],
+        // per-branch guard in src/popup/viewRouter.js. The sweep drives the
+        // container shapes below onto every restorable view; hostileRestore
+        // adds the records that PASS a branch's gate and then hand its
+        // renderer something it dereferences, which is where the entries are
+        // actually decided.
+        hostile: [42, "notarecord", { a: 1 }, [1, 2]],
+        // `structuredClone(saved.viewData || {})`: the container is never falsy
+        // in state whatever was stored, so no `!state.viewData` branch exists to
+        // drive.
+        neverFalsy: true,
+        hostileRestore: [
+            // success-tx passes on `data.hash`, and renderSuccess() then calls
+            // toAddressHtml(d.to) -> addressTitle() -> address.toLowerCase().
+            { value: { hash: "0x1" }, views: ["success-tx"] },
+            { value: { hash: "0x1", to: 42 }, views: ["success-tx"] },
+            {
+                value: { hash: "0x1", to: ADDRESS, decoded: { details: 7 } },
+                views: ["success-tx"],
+            },
+            {
+                value: {
+                    hash: "0x1",
+                    to: ADDRESS,
+                    decoded: { details: [{ address: 42 }] },
+                },
+                views: ["success-tx"],
+            },
+            // error-tx passes on `data.message`, same dereference.
+            { value: { message: "boom" }, views: ["error-tx"] },
+            { value: { message: "boom", to: 42 }, views: ["error-tx"] },
+            // transaction passes on `data.tx`.
+            { value: { tx: { hash: "0x1" } }, views: ["transaction"] },
+            {
+                value: {
+                    tx: {
+                        hash: "0x1",
+                        from: ADDRESS,
+                        to: ADDRESS,
+                        contractAddress: 42,
+                    },
+                },
+                views: ["transaction"],
+            },
+            // confirm-tx passes on `data.pendingTx`.
+            { value: { pendingTx: { amount: "1" } }, views: ["confirm-tx"] },
+            {
+                value: {
+                    pendingTx: {
+                        token: 42,
+                        from: ADDRESS,
+                        to: ADDRESS,
+                        amount: "1",
+                    },
+                },
+                views: ["confirm-tx"],
+            },
+            // wait-tx passes on `pendingWait.hash`; restoreWait() has checked
+            // the fields below it since it was written, and this is the
+            // regression guard.
+            {
+                value: {
+                    pendingWait: {
+                        hash: "0x1",
+                        txInfo: { to: 42, amount: "1" },
+                    },
+                },
+                views: ["wait-tx"],
+            },
+            // A record that passes EVERY branch's gate at once, driven onto
+            // every restorable view: a branch a view does not read must stay
+            // one it does not read, and each renderer must survive the fields
+            // another branch left behind.
+            {
+                value: {
+                    hash: "0x1",
+                    message: "boom",
+                    tx: { hash: "0x1" },
+                    pendingTx: { amount: "1" },
+                    pendingWait: { hash: "0x1" },
+                },
+            },
+        ],
    },
    {
        field: "lastBalanceRefresh",
@@ -245,6 +410,10 @@ const CONTRACT = [
        // Arithmetic only: `now - (s.lastBalanceRefresh || 0)` compares false
        // for a non-number and forces a refresh.
        hostile: [true, "notatime", { a: 1 }],
+        // `|| 0` collapses every falsy stored value to 0, so 0 IS the whole
+        // falsy polarity of this field — and it is the DEFAULT_STATE default,
+        // the value a profile carries until its first refresh lands.
+        falsy: [0],
    },
    {
        field: "tokenHolderCache",
@@ -254,6 +423,8 @@ const CONTRACT = [
        // src/shared/state.js, which are safe for any value, and otherwise
        // only reset wholesale in src/shared/chainSwitchFields.js.
        hostile: [42, "notarecord", [1, 2]],
+        // `structuredClone(saved.tokenHolderCache || {})`.
+        neverFalsy: true,
    },
    {
        field: "theme",
@@ -261,11 +432,16 @@ const CONTRACT = [
        // Compared against "dark"/"light" in applyTheme() and otherwise falls
        // to the system branch; assigned into an input .value, which coerces.
        hostile: [42, "chartreuse", { a: 1 }],
+        // `saved.theme || "system"`.
+        neverFalsy: true,
    },
    {
        field: "dustThresholdGwei",
        kind: KIND.LOOSE,
        hostile: ["notanumber", true, { a: 1 }],
+        // Survives verbatim, so the falsy slot is also wrong-typed: "" reaches
+        // filterTransactions() as a comparand and a settings input .value.
+        falsy: [""],
    },
    ...[
        "rememberSiteChoice",
@@ -281,6 +457,10 @@ const CONTRACT = [
        kind: KIND.LOOSE,
        // A flag: only ever tested for truthiness, and written back verbatim.
        hostile: [42, "notabool", { a: 1 }],
+        // Both answers to that truthiness test have to be driven, and 0 is a
+        // value src/ never writes for a flag. For utcTimestamps and debugMode
+        // the falsy answer is also the DEFAULT_STATE default.
+        falsy: [0],
    })),
 ];

@@ -322,6 +502,10 @@ function profileWith(field, value) {
 }

 describe("the floor each row claims", () => {
+    // The falsy slot is deliberately NOT in here. `saved.x || default` is a
+    // floor on falsy values and on nothing else, so a falsy value is the one
+    // thing a LOOSE field need not carry through verbatim; what it has to carry
+    // through is being falsy, which "both polarities" below asserts.
    for (const row of CONTRACT) {
        const values = [...row.hostile, ...(row.floorOnly || [])];

@@ -354,16 +538,22 @@ describe("the floor each row claims", () => {

        if (row.kind === KIND.LOOSE) {
            test(`${row.field}: is genuinely unfloored`, () => {
-                const survived = values.some((value) => {
+                // EVERY value, not some: a PARTIAL floor is still a floor, and
+                // a row that keeps saying LOOSE because one hostile value out
+                // of three still survives is exactly the stale claim this file
+                // exists to stop.
+                for (const value of values) {
                    const out = normalizePersisted(
                        profileWith(row.field, value),
                    );
-                    return (
-                        JSON.stringify(out[row.field]) === JSON.stringify(value)
-                    );
-                });
-
-                expect(survived).toBe(true);
+                    expect({
+                        value: value,
+                        survived: JSON.stringify(out[row.field]),
+                    }).toEqual({
+                        value: value,
+                        survived: JSON.stringify(value),
+                    });
+                }
            });
        }
    }
@@ -385,9 +575,53 @@ async function bootHealth(profile) {

 const HEALTHY = { errors: [], blank: false };

-describe("a hostile value for one field, through the real popup", () => {
+// unversionedValidProfile() stores no currentView, so every boot in here lands
+// on Home. That is the cheap half of the proof; the restore path below is the
+// half that matters.
+// Both polarities of every swept field are driven, or the field is proven
+// unable to take one of them. This is the guard on the sweep itself: a hostile
+// set is all-truthy by construction, so without a falsy slot a dereference
+// behind `if (!state.x)` is never reached on the boot that corrupts x — the
+// same falsy-collapse blind spot the fields below were floored for.
+describe("both polarities of every swept field are driven", () => {
+    const FALSY_STORED = [0, "", false, null];
+    const floored = (field, value) =>
+        normalizePersisted(profileWith(field, value))[field];
+
    for (const row of CONTRACT) {
-        for (const value of row.hostile) {
+        if (!swept(row)) continue;
+
+        if (row.neverFalsy) {
+            test(`${row.field}: cannot be falsy in state at all`, () => {
+                for (const value of FALSY_STORED) {
+                    expect({
+                        stored: value,
+                        truthy: Boolean(floored(row.field, value)),
+                    }).toEqual({ stored: value, truthy: true });
+                }
+            });
+            continue;
+        }
+
+        test(`${row.field}: truthy and falsy`, () => {
+            // What the boots below actually drive, floored the way a renderer
+            // sees it — not what the row says it drives.
+            const driven = [
+                ...sweptValues(row),
+                ...(row.hostileRestore || []).map((entry) => entry.value),
+            ].map((value) => floored(row.field, value));
+
+            expect({
+                truthy: driven.some((value) => Boolean(value)),
+                falsy: driven.some((value) => !value),
+            }).toEqual({ truthy: true, falsy: true });
+        });
+    }
+});
+
+describe("a hostile value for one field, booting onto Home", () => {
+    for (const row of CONTRACT) {
+        for (const value of sweptValues(row)) {
            test(`${row.field} = ${JSON.stringify(value)}`, async () => {
                await expect(
                    bootHealth(profileWith(row.field, value)),
@@ -409,72 +643,49 @@ describe("a row's extra proof against the real reader", () => {
    }
 });

-// ------------------------------------------------- viewData, entry by entry
+// ------------------------------------------------ driving the restore path

-// The views that read viewData.
-const DATA_VIEWS = [
-    "confirm-tx",
-    "transaction",
-    "wait-tx",
-    "success-tx",
-    "error-tx",
-];
+// Everything above lands on Home. Home is not where this class of defect
+// lives: all three of the false claims this file replaced were falsified by a
+// RESTORE, through the unguarded restoreView() in src/popup/index.js. So a
+// swept row's hostile values are driven onto EVERY restorable view, one boot
+// each.
+//
+// This is what makes a LOOSE row falsifiable. A field that gains a structural
+// dereference on any restorable view — `state.theme.toLowerCase()` in a view's
+// show(), say — turns the row red here, instead of waiting for a reviewer to
+// re-derive the claim by hand.

-// Each record below PASSES the gate of the branch it names, and then carries a
-// value that branch's renderer dereferences. `views` is where it is driven from
-// — the whole set for a value that is not a record at all, and otherwise the
-// branch it targets, since the cross-view case is covered by EVERY_GATE below.
-const HOSTILE_VIEW_DATA = [
-    { data: 42, views: DATA_VIEWS },
-    { data: "notarecord", views: DATA_VIEWS },
-    { data: [1, 2], views: DATA_VIEWS },
-    // success-tx passes on `data.hash`, and renderSuccess() then calls
-    // toAddressHtml(d.to) -> addressTitle() -> address.toLowerCase().
-    { data: { hash: "0x1" }, views: ["success-tx"] },
-    { data: { hash: "0x1", to: 42 }, views: ["success-tx"] },
-    {
-        data: { hash: "0x1", to: ADDRESS, decoded: { details: 7 } },
-        views: ["success-tx"],
+// restoreWait() resumes from this, so it has to be a finite number and recent
+// enough that the resumed deadline has not already passed — a wait that has
+// outlived its deadline resolves on the first poll instead of staying on
+// screen. Read once at module load, so every boot in one run shares it.
+const BROADCAST_TIME = Date.now();
+
+// A viewData well formed for every restorable branch at once, so the only
+// thing a swept boot can fail on is the field the row corrupts. "the base
+// profile the sweep corrupts" below proves this really does render each view
+// rather than falling back — without that, a sweep could pass by never
+// reaching a renderer at all.
+const WELL_FORMED_DATA = {
+    hash: "0x1",
+    message: "boom",
+    to: ADDRESS,
+    decoded: { details: [{ address: TOKEN_ADDRESS }] },
+    tx: { hash: "0x1", from: ADDRESS, to: ADDRESS, contractAddress: null },
+    pendingTx: {
+        token: "ETH",
+        from: ADDRESS,
+        to: ADDRESS,
+        amount: "1",
+        balance: "2",
    },
-    {
-        data: {
-            hash: "0x1",
-            to: ADDRESS,
-            decoded: { details: [{ address: 42 }] },
-        },
-        views: ["success-tx"],
+    pendingWait: {
+        hash: "0x1",
+        txInfo: { to: ADDRESS, amount: "1" },
+        broadcastTime: BROADCAST_TIME,
    },
-    // error-tx passes on `data.message`, same dereference.
-    { data: { message: "boom" }, views: ["error-tx"] },
-    { data: { message: "boom", to: 42 }, views: ["error-tx"] },
-    // transaction passes on `data.tx`.
-    { data: { tx: { hash: "0x1" } }, views: ["transaction"] },
-    {
-        data: {
-            tx: {
-                hash: "0x1",
-                from: ADDRESS,
-                to: ADDRESS,
-                contractAddress: 42,
-            },
-        },
-        views: ["transaction"],
-    },
-    // confirm-tx passes on `data.pendingTx`.
-    { data: { pendingTx: { amount: "1" } }, views: ["confirm-tx"] },
-    {
-        data: {
-            pendingTx: { token: 42, from: ADDRESS, to: ADDRESS, amount: "1" },
-        },
-        views: ["confirm-tx"],
-    },
-    // wait-tx passes on `pendingWait.hash`; restoreWait() has checked the
-    // fields below it since it was written, and this is the regression guard.
-    {
-        data: { pendingWait: { hash: "0x1", txInfo: { to: 42, amount: "1" } } },
-        views: ["wait-tx"],
-    },
-];
+};

 function restoringOnto(view, extra) {
    return unversionedValidProfile({
@@ -483,88 +694,171 @@ function restoringOnto(view, extra) {
        selectedAddress: 0,
        selectedToken: TOKEN_ADDRESS,
        viewStack: ["main"],
+        viewData: WELL_FORMED_DATA,
        ...extra,
    });
 }

-describe("a malformed viewData restoring onto", () => {
-    for (const { data, views } of HOSTILE_VIEW_DATA) {
-        for (const view of views) {
-            test(`${view}: ${JSON.stringify(data)}`, async () => {
-                await expect(
-                    bootHealth(restoringOnto(view, { viewData: data })),
-                ).resolves.toEqual(HEALTHY);
-            });
-        }
-    }
-
-    // Every restorable view, against one record that passes every branch's
-    // gate at once: a branch a view does not read must stay one it does not
-    // read, and each renderer must survive the fields another branch left.
-    const EVERY_GATE = {
-        hash: "0x1",
-        message: "boom",
-        tx: { hash: "0x1" },
-        pendingTx: { amount: "1" },
-        pendingWait: { hash: "0x1" },
+// A boot that RESTORED is healthy and landed on the view it stored, rather
+// than falling back to Home — which a healthy boot also does, and which would
+// let a sweep pass by never running the renderer it is aimed at.
+async function restoredHealth(profile, view) {
+    const env = await bootPopup(profile);
+    return {
+        errors: env.pageErrors,
+        restored: env.visibleViews().includes(view),
    };
+}
+
+const RESTORED = { errors: [], restored: true };
+
+describe("the base profile the sweep corrupts", () => {
    for (const view of RESTORABLE_VIEWS) {
-        test(`${view}: a record passing every branch's gate at once`, async () => {
+        test(`renders ${view} rather than falling back`, async () => {
            await expect(
-                bootHealth(restoringOnto(view, { viewData: EVERY_GATE })),
-            ).resolves.toEqual(HEALTHY);
+                restoredHealth(restoringOnto(view), view),
+            ).resolves.toEqual(RESTORED);
        });
    }
 });

-// --------------------------------------- selectedWallet / selectedAddress
+// A field the ROUTER itself reads — the two it gates on and the two
+// hasValidAddress() indexes with. A hostile value in one of these legitimately
+// changes which view renders, so each gets its own boot per view and is held
+// only to "healthy", not to "restored onto the view it stored".
+const routes = (row) => Boolean(row.routes);

-// `wallets` is a real Array, so a selectedWallet naming an Array.prototype or
-// Object.prototype member is TRUTHY: hasValidAddress()'s `&&` does not
-// short-circuit, `.addresses` is undefined, and the index access throws out of
-// restoreView(). A stale INTEGER is falsy-or-in-range and safe — the opposite
-// way round from how this pair was described.
-const HOSTILE_INDEX = [
-    { selectedWallet: "map", selectedAddress: 0 },
-    { selectedWallet: "length", selectedAddress: 0 },
-    { selectedWallet: "__proto__", selectedAddress: 0 },
-    { selectedWallet: "constructor", selectedAddress: 0 },
-    { selectedWallet: 0, selectedAddress: "map" },
-    { selectedWallet: 5, selectedAddress: 0 },
-];
+// Every routing row × every hostile value × every restorable view. Profiles
+// are deduplicated because a hostile `currentView` REPLACES the view being
+// restored onto, which would otherwise be the same boot eleven times.
+describe("a hostile routing value restoring onto", () => {
+    for (const row of CONTRACT) {
+        if (!swept(row) || !routes(row)) continue;
+        const seen = new Set();
+        for (const value of sweptValues(row)) {
+            for (const view of RESTORABLE_VIEWS) {
+                const profile = restoringOnto(view, { [row.field]: value });
+                const key = JSON.stringify(profile);
+                if (seen.has(key)) continue;
+                seen.add(key);
+                test(`${view}: ${row.field} = ${JSON.stringify(
+                    value,
+                )}`, async () => {
+                    await expect(bootHealth(profile)).resolves.toEqual(HEALTHY);
+                });
+            }
+        }
+    }
+});

-const INDEX_VIEWS = [
-    "address",
-    "address-token",
-    "receive",
-    "transaction",
-    "confirm-tx",
-];
+// Every OTHER swept field, corrupted at once, one boot per view per hostile
+// slot: twelve fields on one boot rather than twelve boots. A field is only in
+// here because it is not one the router reads — and that is ASSERTED, not
+// argued, because the boot has to land on `view`. A field that does move the
+// routing turns this red and has to declare `routes` and take the individual
+// sweep above.
+//
+// Combining hides one thing, and the last slot is what stops it. A hostile
+// value is wrong-typed and therefore TRUTHY, so on a boot where every swept
+// field is hostile, no `if (!state.x)` branch is entered — and a dereference
+// inside such a branch would go unseen however loudly it throws. The last slot
+// is the falsy one: every swept field that CAN be falsy is falsy on it, which
+// is also the state an ordinary install boots in for three of them, while the
+// fields that cannot be falsy stay hostile-truthy. That makes it a MIX, and a
+// deliberate one — the interaction between a falsy flag and a still-hostile
+// theme is a shape a stored record really produces.
+//
+// The verdict is the combined boot, always. When it goes red the same view is
+// re-booted one field at a time, so the failure NAMES a culprit instead of
+// leaving a reader to bisect twelve fields — but that loop only decorates the
+// message. It cannot clear the failure. A dereference that needs two corrupted
+// fields at once is reproduced by neither field alone, and a version of this
+// file that asserted on the named list reported exactly that case green while
+// watching the popup die.
+const UNROUTED = CONTRACT.filter((row) => swept(row) && !routes(row));
+const HOSTILE_SLOTS = Math.max(
+    ...UNROUTED.map((row) => sweptValues(row).length),
+);

-describe("a malformed wallet or address index restoring onto", () => {
-    const WELL_FORMED_DATA = {
-        tx: { hash: "0x1", from: ADDRESS, to: ADDRESS },
-        pendingTx: {
-            token: "ETH",
-            from: ADDRESS,
-            to: ADDRESS,
-            amount: "1",
-            balance: "2",
-        },
-    };
+function unroutedValues(slot) {
+    const fields = {};
+    for (const row of UNROUTED) {
+        const values = sweptValues(row);
+        fields[row.field] = values[slot % values.length];
+    }
+    return fields;
+}

-    for (const view of INDEX_VIEWS) {
-        for (const indices of HOSTILE_INDEX) {
-            test(`${view}: ${JSON.stringify(indices)}`, async () => {
-                await expect(
-                    bootHealth(
-                        restoringOnto(view, {
-                            ...indices,
-                            viewData: WELL_FORMED_DATA,
-                        }),
-                    ),
-                ).resolves.toEqual(HEALTHY);
+describe("every field the router does not read, corrupted at once, onto", () => {
+    for (const view of RESTORABLE_VIEWS) {
+        for (let slot = 0; slot < HOSTILE_SLOTS; slot++) {
+            test(`${view}: hostile value ${slot + 1} in all ${
+                UNROUTED.length
+            } of them`, async () => {
+                const fields = unroutedValues(slot);
+                const together = await restoredHealth(
+                    restoringOnto(view, fields),
+                    view,
+                );
+
+                // The per-field re-boot only DECORATES the message. The
+                // verdict is `together`, unconditionally: a dereference that
+                // needs two corrupted fields at once is reproduced by NEITHER
+                // field alone, so an assertion on the named list would report
+                // an observed dead popup as green.
+                const named = [];
+                if (together.errors.length > 0 || !together.restored) {
+                    for (const row of UNROUTED) {
+                        const one = await restoredHealth(
+                            restoringOnto(view, {
+                                [row.field]: fields[row.field],
+                            }),
+                            view,
+                        );
+                        if (one.errors.length === 0 && one.restored) continue;
+                        named.push(
+                            `${row.field}=${JSON.stringify(
+                                fields[row.field],
+                            )}: ` +
+                                (one.errors.join("; ") || `fell off ${view}`),
+                        );
+                    }
+                    if (named.length === 0) {
+                        named.push(
+                            "no single field reproduces it; it takes two or " +
+                                `more of ${JSON.stringify(fields)}`,
+                        );
+                    }
+                }
+
+                expect({
+                    view: view,
+                    together: together,
+                    fields: named,
+                }).toEqual({ view: view, together: RESTORED, fields: [] });
            });
        }
    }
 });
+
+// The values that only mean something on the restore path: a viewData that
+// PASSES a branch's gate and then hands its renderer something dereferenced,
+// and the index values whose route through hasValidAddress() differs from the
+// row's own hostile set.
+describe("a restore-only hostile value onto", () => {
+    for (const row of CONTRACT) {
+        for (const entry of row.hostileRestore || []) {
+            for (const view of entry.views || RESTORABLE_VIEWS) {
+                test(`${view}: ${row.field} = ${JSON.stringify(
+                    entry.value,
+                )}`, async () => {
+                    await expect(
+                        bootHealth(
+                            restoringOnto(view, { [row.field]: entry.value }),
+                        ),
+                    ).resolves.toEqual(HEALTHY);
+                });
+            }
+        }
+    }
+});
@@ -0,0 +1,156 @@
+// The symbol the dApp approval and status screens label a token with.
+//
+// Issue #323: the approval screen labelled anything outside the bundled list
+// `Unknown token`, even a token the user tracks or holds a balance of, while
+// the amount line already read that token's *scale* from those same sources
+// (issue #306). The name and the scale disagreed about which sources they
+// trust. resolveTokenSymbol() closes that gap: it draws the symbol from the
+// bundled list, then the tracked tokens, then the explorer's report — the
+// precedence resolveTokenDecimals() uses — and returns null, not a guess,
+// when nothing names it, so the screens keep saying `Unknown token`.
+//
+// A tracked or explorer-reported symbol is attacker-influenced text, so it
+// stays subject to the spoof rule (src/shared/symbolSpoof.js): resolving a
+// symbol must not become a new way for a stray contract to wear a bundled or
+// native ticker.
+
+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 { resolveTokenSymbol } = 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: USDC at 6 decimals, DAI at 18.
+const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
+const FIVE_THOUSAND_AT_SIX = 5000000000n;
+
+function transferData(amount) {
+    return iface.encodeFunctionData("transfer", [RECIPIENT, amount]);
+}
+
+// A wallet whose block-explorer balance for `token` reports `symbol`, shaped
+// as balances.js writes it onto state.
+function walletsReporting(token, symbol) {
+    return [
+        {
+            name: "Wallet 1",
+            addresses: [
+                {
+                    address: "0x" + "a".repeat(40),
+                    balance: "1.0",
+                    tokenBalances: [
+                        {
+                            address: token,
+                            symbol,
+                            decimals: 6,
+                            balance: "5000.0",
+                        },
+                    ],
+                },
+            ],
+        },
+    ];
+}
+
+beforeEach(() => {
+    state.trackedTokens = [];
+    state.wallets = [];
+});
+
+describe("resolveTokenSymbol", () => {
+    test("reads the bundled list", () => {
+        expect(resolveTokenSymbol(USDC, state)).toBe("USDC");
+    });
+
+    test("prefers the bundled list over a tracked entry", () => {
+        state.trackedTokens = [{ address: USDC, symbol: "NOTUSDC" }];
+        expect(resolveTokenSymbol(USDC, state)).toBe("USDC");
+    });
+
+    test("reads a token the user tracks", () => {
+        state.trackedTokens = [{ address: NOVEL_TOKEN, symbol: "NOVEL" }];
+        expect(resolveTokenSymbol(NOVEL_TOKEN, state)).toBe("NOVEL");
+    });
+
+    test("reads the symbol the explorer reported", () => {
+        state.wallets = walletsReporting(NOVEL_TOKEN, "NOVEL");
+        expect(resolveTokenSymbol(NOVEL_TOKEN, state)).toBe("NOVEL");
+    });
+
+    test("is null when no source names the token", () => {
+        expect(resolveTokenSymbol(NOVEL_TOKEN, state)).toBeNull();
+    });
+
+    test("refuses a name the explorer's own entries disagree about", () => {
+        const wallets = walletsReporting(NOVEL_TOKEN, "NOVEL");
+        wallets[0].addresses.push({
+            address: "0x" + "b".repeat(40),
+            balance: "0.0",
+            tokenBalances: [{ address: NOVEL_TOKEN, symbol: "OTHER" }],
+        });
+        state.wallets = wallets;
+        expect(resolveTokenSymbol(NOVEL_TOKEN, state)).toBeNull();
+    });
+
+    test("rejects a tracked entry claiming a bundled ticker it is not", () => {
+        // NOVEL_TOKEN is not the real USDC contract, so it may not wear USDC.
+        state.trackedTokens = [{ address: NOVEL_TOKEN, symbol: "USDC" }];
+        expect(resolveTokenSymbol(NOVEL_TOKEN, state)).toBeNull();
+    });
+
+    test("rejects an explorer entry claiming the native ETH ticker", () => {
+        state.wallets = walletsReporting(NOVEL_TOKEN, "ETH");
+        expect(resolveTokenSymbol(NOVEL_TOKEN, state)).toBeNull();
+    });
+});
+
+describe("decodeCalldata symbol", () => {
+    test("a tracked token is named, not called Unknown", () => {
+        state.trackedTokens = [
+            { address: NOVEL_TOKEN, symbol: "NOVEL", decimals: 6 },
+        ];
+        const decoded = decodeCalldata(
+            transferData(FIVE_THOUSAND_AT_SIX),
+            NOVEL_TOKEN,
+        );
+        expect(decoded.description).toBe("Transfer NOVEL");
+        const amount = decoded.details.find((d) => d.label === "Amount");
+        expect(amount.value).toBe("5000.0000 NOVEL");
+    });
+
+    test("a token nothing knows keeps a symbol-less label", () => {
+        const decoded = decodeCalldata(
+            transferData(FIVE_THOUSAND_AT_SIX),
+            NOVEL_TOKEN,
+        );
+        expect(decoded.description).toBe("Transfer ERC-20 token");
+        const token = decoded.details.find((d) => d.label === "Token");
+        // The Token line carries the address and is flagged for the screen's
+        // symbol lookup, which resolves to nothing here — so `Unknown token`.
+        expect(token.isToken).toBe(true);
+        expect(token.address).toBe(NOVEL_TOKEN);
+        expect(resolveTokenSymbol(token.address, state)).toBeNull();
+    });
+
+    test("a tracked token spoofing a bundled ticker is not named by it", () => {
+        state.trackedTokens = [
+            { address: NOVEL_TOKEN, symbol: "USDC", decimals: 6 },
+        ];
+        const decoded = decodeCalldata(
+            transferData(FIVE_THOUSAND_AT_SIX),
+            NOVEL_TOKEN,
+        );
+        expect(decoded.description).toBe("Transfer ERC-20 token");
+        const amount = decoded.details.find((d) => d.label === "Amount");
+        expect(amount.value).not.toMatch(/USDC/);
+    });
+});
@@ -120,6 +120,20 @@ function makeElement(id, className) {
            el.clicked += 1;
        },
    };
+    // src/ reaches parentElement only to hide or unhide the wrapper a field
+    // sits in (txStatus.js renderSuccess(), transactionDetail.js render()).
+    // The stub is flat — it is built from the ids in the markup, not from its
+    // tree — so each element gets a wrapper of its own, made on demand so this
+    // does not recurse. It is never registered by id, so nothing can mistake
+    // it for a view. Without it, success-tx and transaction throw on the first
+    // line that touches a wrapper and cannot be booted onto at all.
+    let parent = null;
+    Object.defineProperty(el, "parentElement", {
+        get() {
+            if (!parent) parent = makeElement(id + "-parent", "");
+            return parent;
+        },
+    });
    return el;
 }

@@ -78,15 +78,20 @@ describe("a swap to a token absent from the bundled list", () => {
        );
    });

-    test("names the address when the scale is known but the symbol is not", () => {
+    test("names the tracked symbol alongside the address (issue #323)", () => {
+        // The tracked entry supplies both halves now: the scale, and the
+        // symbol the output line is named by. Before #323 the symbol was read
+        // from the bundled list alone, so this line fell back to the address.
        const sources = {
            trackedTokens: [
                { address: NOVEL_OUT, symbol: "NOVEL", decimals: 6 },
            ],
        };
-        expect(detail(data(), "Token Out", sources).value).toBe(NOVEL_OUT);
+        expect(detail(data(), "Token Out", sources).value).toBe(
+            "NOVEL (" + NOVEL_OUT + ")",
+        );
        expect(detail(data(), "Min. received", sources).value).toBe(
-            "1000.0000",
+            "1000.0000 NOVEL",
        );
    });
 });
@@ -98,12 +98,13 @@ describe("a swap of a token outside the bundled list", () => {
        state.trackedTokens = [
            { address: NOVEL, symbol: "NOVEL", decimals: 6 },
        ];
-        expect(swapDetail(data(), "Amount").value).toBe("1000.0000");
+        // The tracked entry names the token as well as scaling it (issue #323).
+        expect(swapDetail(data(), "Amount").value).toBe("1000.0000 NOVEL");
    });

    test("shows the true quantity from the explorer's decimals", () => {
        state.wallets = walletsHolding(NOVEL, "6");
-        expect(swapDetail(data(), "Amount").value).toBe("1000.0000");
+        expect(swapDetail(data(), "Amount").value).toBe("1000.0000 NOVEL");
    });

    test("refuses to format when nothing knows the scale", () => {
@@ -140,7 +141,7 @@ describe("the Min. received line takes the same rule", () => {
            { address: NOVEL_OUT, symbol: "NOVEL", decimals: 6 },
        ];
        const data = swapData(WETH, HALF_WETH, NOVEL_OUT, THOUSAND_AT_SIX);
-        expect(swapDetail(data, "Min. received").value).toBe("1000.0000");
+        expect(swapDetail(data, "Min. received").value).toBe("1000.0000 NOVEL");
    });
 });

@@ -0,0 +1,185 @@
+// What the screens that READ a stored token balance do with a holding whose
+// scale nothing knows.
+//
+// https://git.eeqj.de/sneak/AutistMask/issues/349 stopped `fetchTokenBalances()`
+// fabricating a scale of 18, so a row it cannot state a quantity for is now
+// stored with `balance: null`. Every reader of that field therefore has two
+// distinct inputs where it used to have one, and the property that has to hold
+// at each of them is the same one this codebase keeps losing:
+//
+//     null (unknown) and 0 (genuinely zero) must produce DIFFERENT output.
+//
+// Losing it is what https://git.eeqj.de/sneak/AutistMask/issues/246,
+// https://git.eeqj.de/sneak/AutistMask/issues/306,
+// https://git.eeqj.de/sneak/AutistMask/issues/322,
+// https://git.eeqj.de/sneak/AutistMask/issues/359 and
+// https://git.eeqj.de/sneak/AutistMask/issues/364 each were. So every case
+// below asserts the pair, not just that the null branch does something
+// reasonable: an assertion on the null alone still passes on a build that
+// renders both as zero, which is precisely the build being guarded against.
+//
+// The writer half — that the fetcher stores null rather than 18 — is in
+// tests/fabricatedDecimals.test.js, and the Send and confirmation screens are
+// in tests/unknownScaleSend.test.js.
+
+"use strict";
+
+// helpers.js reaches for both at module scope through the modules it pulls in.
+globalThis.chrome = {
+    storage: {
+        local: {
+            get: () => Promise.resolve({}),
+            set: () => Promise.resolve(),
+        },
+    },
+    runtime: { sendMessage: () => {} },
+};
+globalThis.document = {
+    getElementById: () => null,
+    createElement: () => ({ style: {}, classList: { toggle() {} } }),
+    body: { prepend: () => {} },
+    addEventListener: () => {},
+};
+
+const {
+    balanceLine,
+    balanceLinesForAddress,
+    addressHoldsFunds,
+} = require("../src/popup/views/helpers");
+const {
+    prices,
+    clearPrices,
+    getAddressValue,
+} = require("../src/shared/prices");
+const { state } = require("../src/shared/state");
+
+const NOVEL = "0x1111111111111111111111111111111111111111";
+
+// One stored tokenBalances row. `balance: null` is what balances.js writes for
+// a holding whose scale nothing knows; "0.0" is a quantity that was actually
+// established and is zero.
+function holding(balance) {
+    return {
+        address: NOVEL,
+        symbol: "NOVEL",
+        decimals: balance === null ? null : 18,
+        balance,
+        holders: 50000,
+    };
+}
+
+function address(balance) {
+    return {
+        address: "0x" + "a".repeat(40),
+        balance: "0",
+        tokenBalances: [holding(balance)],
+    };
+}
+
+// The quantity cell of a rendered row, which is the second of the two spans
+// inside the fixed-width span.
+function quantities(html) {
+    return [...html.matchAll(/<span>([^<]*)<\/span>/g)].map((m) => m[1]);
+}
+
+beforeEach(() => {
+    clearPrices();
+    state.wallets = [];
+    state.trackedTokens = [];
+    state.activeAddress = null;
+});
+
+afterEach(() => {
+    clearPrices();
+});
+
+describe("balanceLine", () => {
+    test("an unknown quantity and a zero one render differently", () => {
+        const unknown = balanceLine("NOVEL", null, null, NOVEL);
+        const zero = balanceLine("NOVEL", 0, null, NOVEL);
+        expect(unknown).not.toBe(zero);
+        expect(quantities(unknown)).toEqual(["NOVEL", "quantity unknown"]);
+        expect(quantities(zero)).toEqual(["NOVEL", "0.0000"]);
+    });
+
+    test("an unknown quantity produces no fiat figure, a zero one does", () => {
+        prices.NOVEL = 3;
+        const unknown = balanceLine("NOVEL", null, 3, NOVEL);
+        const zero = balanceLine("NOVEL", 0, 3, NOVEL);
+        // A price times an unknown quantity is not $0.00: that is the same
+        // claim of "nothing here" the quantity cell just refused to make.
+        expect(unknown).toContain(
+            '<span class="text-right text-muted flex-1">&nbsp;</span>',
+        );
+        expect(zero).toContain(
+            '<span class="text-right text-muted flex-1">$0.00</span>',
+        );
+    });
+});
+
+describe("balanceLinesForAddress", () => {
+    // The show-zero setting is a statement about zeroes. An unknown quantity
+    // is not one, so hiding the row would assert the zero nobody established
+    // and the holding would vanish from the list entirely.
+    test("hiding zero balances hides the zero row and keeps the unknown one", () => {
+        const unknown = balanceLinesForAddress(address(null), [], false);
+        const zero = balanceLinesForAddress(address("0.0"), [], false);
+        expect(unknown).not.toBe(zero);
+        expect(unknown).toContain("quantity unknown");
+        expect(unknown).toContain("NOVEL");
+        expect(zero).not.toContain("NOVEL");
+    });
+
+    test("showing zero balances still tells the two apart", () => {
+        const unknown = balanceLinesForAddress(address(null), [], true);
+        const zero = balanceLinesForAddress(address("0.0"), [], true);
+        expect(unknown).not.toBe(zero);
+        expect(quantities(unknown)).toEqual([
+            "ETH",
+            "0.0000",
+            "NOVEL",
+            "quantity unknown",
+        ]);
+        expect(quantities(zero)).toEqual(["ETH", "0.0000", "NOVEL", "0.0000"]);
+    });
+});
+
+describe("addressHoldsFunds", () => {
+    // Read by deleteAddress.js to decide whether removing the address is
+    // warned about. balances.js drops a row of zero base units before any
+    // scale is consulted, so a row that survived with no quantity is holding
+    // something, and the warning must err towards warning.
+    test("an unknown balance holds funds, a zero balance does not", () => {
+        expect(addressHoldsFunds(address(null))).toBe(true);
+        expect(addressHoldsFunds(address("0.0"))).toBe(false);
+    });
+});
+
+describe("getAddressValue", () => {
+    // `usd` is the value of what could be priced and `partial` says it is a
+    // floor rather than the total. An unpriceable holding is exactly what
+    // `partial` exists for; a holding of zero can neither add to the total nor
+    // make it incomplete.
+    test("an unknown balance makes the total partial, a zero balance does not", () => {
+        prices.ETH = 2000;
+        prices.NOVEL = 3;
+        const unknown = getAddressValue(address(null));
+        const zero = getAddressValue(address("0.0"));
+        expect(unknown).not.toEqual(zero);
+        expect(unknown).toEqual({ usd: 0, partial: true });
+        expect(zero).toEqual({ usd: 0, partial: false });
+    });
+
+    test("an unknown balance is not priced as zero of the token", () => {
+        prices.ETH = 2000;
+        prices.NOVEL = 3;
+        // The same row with a real quantity of 10 is worth $30. Neither that
+        // figure nor a confident $0.00 may be stated for the unknown one.
+        expect(getAddressValue(address("10.0"))).toEqual({
+            usd: 30,
+            partial: false,
+        });
+        expect(getAddressValue(address(null)).usd).toBe(0);
+        expect(getAddressValue(address(null)).partial).toBe(true);
+    });
+});
@@ -0,0 +1,455 @@
+// The Send and confirmation screens for a token whose explorer row carries no
+// decimals.
+//
+// https://git.eeqj.de/sneak/AutistMask/issues/349 made `fetchTokenBalances()`
+// store the explorer's own answer — `null` when it reported none — while the
+// scale a balance is DISPLAYED at is resolved separately: bundled list, then
+// the user's tracked tokens, then the explorer. The two are different
+// questions, and `tokenBalances[].decimals` only answers the second one.
+//
+// A reader that takes the stored field for the display scale therefore gets
+// `null` for a token the wallet does know the scale of. On the Send path that
+// null reaches `displayedDecimals()` inside `estimateGas()`, which throws, is
+// caught as an unavailable fee, and disables Send behind "The network fee could
+// not be estimated" — untrue, unactionable, and for a bundled token like WETH
+// or DAI whose scale was never in doubt. So the Send screen resolves the scale
+// the same way the balance list did, and only carries a null forward when that
+// resolution genuinely answers null.
+//
+// Driven through the real `fetchTokenBalances()`, the real Send review handler
+// and the real confirmation screen: a test that hand-wrote `decimals: null`
+// onto state would not show which of the two questions each screen is asking.
+//
+// The reader sites that are pure display are in tests/unknownScaleDisplay.test.js,
+// and what the fetcher stores is in tests/fabricatedDecimals.test.js.
+
+"use strict";
+
+jest.mock("../src/shared/log", () => ({
+    log: {
+        debugf: () => {},
+        infof: () => {},
+        warnf: () => {},
+        errorf: () => {},
+    },
+    debugFetch: jest.fn(),
+    setRuntimeDebug: () => {},
+    isDebug: () => false,
+}));
+
+// Everything the confirmation screen would reach the network for. The gas
+// estimate is the point: with a usable scale it must succeed, so that a failure
+// in these tests is a failure of the scale and not of the stub.
+const mockProvider = {
+    getFeeData: async () => ({
+        maxFeePerGas: 2000000000n,
+        gasPrice: 1000000000n,
+    }),
+    estimateGas: async () => 21000n,
+    getCode: async () => "0x",
+    getTransactionCount: async () => 1,
+    getBalance: async () => 0n,
+};
+
+jest.mock("../src/shared/balances", () => {
+    const actual = jest.requireActual("../src/shared/balances");
+    return { ...actual, getProvider: () => mockProvider };
+});
+
+// The confirmation screen's best-effort Etherscan label lookup is the one
+// thing here that reaches for fetch(). It is stubbed to fail, which is the
+// path it already takes offline; the assertion at the bottom of this file
+// pins that it is the ONLY fetch these screens make.
+global.fetch = jest.fn(() => {
+    throw new Error("tests must not perform network requests");
+});
+
+const { makeStorageStub } = require("./support/storageStub");
+global.chrome = { storage: makeStorageStub(), runtime: { sendMessage() {} } };
+
+// A stub DOM. Every id in index.html that these two views touch resolves to a
+// fresh recording element; nothing here depends on layout, only on what the
+// views write into the elements and which handlers they register.
+const elements = new Map();
+
+function makeEl(id) {
+    const handlers = new Map();
+    return {
+        id,
+        textContent: "",
+        innerHTML: "",
+        value: "",
+        disabled: false,
+        onclick: null,
+        style: {},
+        dataset: {},
+        classList: {
+            add() {},
+            remove() {},
+            toggle() {},
+            contains: () => false,
+        },
+        handlers,
+        addEventListener(name, fn) {
+            handlers.set(name, fn);
+        },
+        appendChild(child) {
+            return child;
+        },
+        querySelectorAll: () => [],
+        querySelector: () => null,
+        remove() {},
+        focus() {},
+    };
+}
+
+global.document = {
+    getElementById(id) {
+        if (!elements.has(id)) elements.set(id, makeEl(id));
+        return elements.get(id);
+    },
+    createElement: (tag) => makeEl(tag),
+    body: { prepend() {}, appendChild() {} },
+    addEventListener() {},
+};
+global.navigator = { clipboard: { writeText() {} } };
+
+const { parseUnits } = require("ethers");
+const { fetchTokenBalances } = require("../src/shared/balances");
+const { debugFetch } = require("../src/shared/log");
+const { state } = require("../src/shared/state");
+const {
+    displayedDecimals,
+    transferAmountUnits,
+} = require("../src/shared/transferAmount");
+const send = require("../src/popup/views/send");
+const confirmTx = require("../src/popup/views/confirmTx");
+const { TOKEN_BY_ADDRESS } = require("../src/shared/tokenList");
+
+const HOLDER = "0x" + "a".repeat(40);
+const SECOND_HOLDER = "0x" + "b".repeat(40);
+const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
+const BLOCKSCOUT = "https://blockscout.example/api/v2";
+// Bundled, 18 decimals. The wallet knows this token's scale without asking
+// anyone, which is what makes an unsendable WETH a regression rather than a
+// refusal.
+const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+// Neither bundled nor tracked, so the explorer is the only possible source and
+// an omission there really is an unknown scale.
+const NOVEL = "0xE2E0000000000000000000000000000000000E2e";
+
+const FIVE_WETH = 5000000000000000000n;
+
+function row(token = {}, value = FIVE_WETH) {
+    return {
+        value: String(value),
+        token: {
+            type: "ERC-20",
+            address_hash: WETH,
+            symbol: "WETH",
+            name: "Wrapped Ether",
+            holders_count: "50000",
+            ...token,
+        },
+    };
+}
+
+// Fetch the explorer's rows through the real fetcher and put them exactly where
+// refreshBalances() puts them.
+async function fetchOnto(items) {
+    debugFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        statusText: "OK",
+        json: async () => items,
+    }));
+    const balances = await fetchTokenBalances(HOLDER, BLOCKSCOUT, []);
+    state.wallets = [
+        {
+            name: "Wallet 1",
+            addresses: [
+                { address: HOLDER, balance: "1.0", tokenBalances: balances },
+            ],
+        },
+    ];
+    state.selectedWallet = 0;
+    state.selectedAddress = 0;
+    return balances;
+}
+
+// The same, for two addresses of one wallet holding the same contract. Sending
+// is from the first. Two addresses is what it takes to reach
+// explorerDecimals()'s disagreement check, which is only reachable across rows.
+async function fetchOntoBoth(itemsA, itemsB) {
+    debugFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        statusText: "OK",
+        json: async () => itemsA,
+    }));
+    const a = await fetchTokenBalances(HOLDER, BLOCKSCOUT, []);
+    debugFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        statusText: "OK",
+        json: async () => itemsB,
+    }));
+    const b = await fetchTokenBalances(SECOND_HOLDER, BLOCKSCOUT, []);
+    state.wallets = [
+        {
+            name: "Wallet 1",
+            addresses: [
+                { address: HOLDER, balance: "1.0", tokenBalances: a },
+                { address: SECOND_HOLDER, balance: "1.0", tokenBalances: b },
+            ],
+        },
+    ];
+    state.selectedWallet = 0;
+    state.selectedAddress = 0;
+    return { a, b };
+}
+
+function el(id) {
+    return global.document.getElementById(id);
+}
+
+// Press Review on the Send screen and return the txInfo it hands the
+// confirmation screen.
+async function reviewSend(tokenAddress, amount) {
+    let handed = null;
+    send.init({ showConfirmTx: (info) => (handed = info) });
+    state.selectedToken = tokenAddress;
+    el("send-token").value = tokenAddress;
+    el("send-to").value = RECIPIENT;
+    el("send-amount").value = amount;
+    await el("btn-send-review").handlers.get("click")();
+    return handed;
+}
+
+// show() kicks off the gas estimate without awaiting it; this lets it settle.
+async function settle() {
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
+}
+
+function text(id) {
+    return el(id).textContent;
+}
+
+function errors() {
+    return el("confirm-errors").innerHTML;
+}
+
+function sendDisabled() {
+    return el("btn-confirm-send").disabled;
+}
+
+beforeEach(() => {
+    elements.clear();
+    debugFetch.mockReset();
+    state.wallets = [];
+    state.trackedTokens = [];
+    state.selectedToken = null;
+    state.fraudContracts = [];
+    state.hideLowHolderTokens = false;
+    state.currentView = null;
+});
+
+describe("the Send screen resolves the scale rather than reading the stored one", () => {
+    test("the bundled list knows WETH, and the explorer row does not report a scale", async () => {
+        expect(TOKEN_BY_ADDRESS.get(WETH.toLowerCase()).decimals).toBe(18);
+        const balances = await fetchOnto([row()]);
+        // Stored: the explorer's own answer, which is nothing. Reading THIS is
+        // what carried a null into the fee estimate.
+        expect(balances[0].decimals).toBeNull();
+        // Displayed: the bundled scale, so the quantity on screen is real.
+        expect(balances[0].balance).toBe("5.0");
+    });
+
+    test("the review hands the confirmation screen the resolved scale, not the stored null", async () => {
+        const balances = await fetchOnto([row()]);
+        const txInfo = await reviewSend(WETH, "1.5");
+        expect(txInfo.tokenDecimals).toBe(18);
+        expect(txInfo.tokenDecimals).not.toBe(balances[0].decimals);
+        expect(txInfo.tokenBalance).toBe("5.0");
+    });
+
+    test("that scale estimates a fee and leaves Send enabled", async () => {
+        await fetchOnto([row()]);
+        const txInfo = await reviewSend(WETH, "1.5");
+        confirmTx.show(txInfo);
+        await settle();
+        // The regression: displayedDecimals(null) threw in estimateGas(), the
+        // catch reported the fee as unknown, and Send stayed disabled behind a
+        // message about the network fee that no retry could clear.
+        expect(text("confirm-fee-amount")).not.toBe("Unable to estimate");
+        expect(text("confirm-fee-amount")).toContain("ETH");
+        expect(errors()).toBe("");
+        expect(sendDisabled()).toBe(false);
+    });
+
+    test("and the transfer encodes at the scale that was displayed", async () => {
+        await fetchOnto([row()]);
+        const txInfo = await reviewSend(WETH, "1.5");
+        // The two calls confirmTx makes with this field: the gas estimate's
+        // scale, and the encode, which compares it against the contract's own
+        // decimals() before parsing.
+        expect(displayedDecimals(txInfo.tokenDecimals)).toBe(18);
+        expect(
+            transferAmountUnits(txInfo.amount, txInfo.tokenDecimals, 18n),
+        ).toBe(parseUnits("1.5", 18));
+    });
+
+    test("a token nothing knows the scale of is still refused, and says why", async () => {
+        await fetchOnto([
+            row({ address_hash: NOVEL, symbol: "NOVEL", name: "Novel Token" }),
+        ]);
+        const txInfo = await reviewSend(NOVEL, "1.5");
+        // No fallback was introduced: resolution answers null here, and the
+        // null is what goes forward.
+        expect(txInfo.tokenDecimals).toBeNull();
+        expect(txInfo.tokenBalance).toBeNull();
+        confirmTx.show(txInfo);
+        await settle();
+        expect(text("confirm-balance")).toBe("unknown (NOVEL)");
+        expect(errors()).toContain("This token&#39;s balance is unknown");
+        expect(sendDisabled()).toBe(true);
+    });
+});
+
+// balances.js resolves the display scale WITHOUT `wallets`, so its explorer leg
+// is the row it is formatting. send.js resolves WITH `wallets`, so its explorer
+// leg is explorerDecimals(), which answers null when two addresses report
+// different scales for one contract — the check that must apply before a scale
+// encodes a transfer. The two therefore disagree exactly here, and a stored
+// balance formatted at a scale the Send screen just refused is not a balance it
+// may state: it would leave validateTransfer() satisfied, the unknown-balance
+// sentence unfired, and the fee-estimate failure as the only thing on screen.
+describe("a scale the explorer's own rows disagree about", () => {
+    // 5000000 units at the "6" address A reports, 5e18 at the "18" address B
+    // reports: both format to "5.0", so the disagreement is in the scale alone
+    // and not in the quantity.
+    function novel(decimals, value) {
+        return row(
+            {
+                address_hash: NOVEL,
+                symbol: "NOVEL",
+                name: "Novel Token",
+                decimals,
+            },
+            value,
+        );
+    }
+
+    test("is stored per row, because storage holds the explorer's own answer", async () => {
+        const { a, b } = await fetchOntoBoth(
+            [novel("6", 5000000n)],
+            [novel("18", FIVE_WETH)],
+        );
+        expect(a[0].decimals).toBe(6);
+        expect(a[0].balance).toBe("5.0");
+        expect(b[0].decimals).toBe(18);
+    });
+
+    test("resolves to null on the Send screen, and takes the balance with it", async () => {
+        await fetchOntoBoth([novel("6", 5000000n)], [novel("18", FIVE_WETH)]);
+        const txInfo = await reviewSend(NOVEL, "1.5");
+        expect(txInfo.tokenDecimals).toBeNull();
+        // The regression this closes: null scale alongside a non-null balance.
+        expect(txInfo.tokenBalance).toBeNull();
+    });
+
+    test("so the user is told the balance is unknown, not only that the fee failed", async () => {
+        await fetchOntoBoth([novel("6", 5000000n)], [novel("18", FIVE_WETH)]);
+        const txInfo = await reviewSend(NOVEL, "1.5");
+        confirmTx.show(txInfo);
+        await settle();
+        // Before the fix: "5.0 NOVEL", an empty confirm-errors, and
+        // confirm-fee-unknown-error — "the network fee could not be
+        // estimated... please go back and try again" — as the only explanation
+        // for a screen that can never proceed.
+        expect(errors()).not.toBe("");
+        expect(errors()).toContain("This token&#39;s balance is unknown");
+        expect(text("confirm-balance")).toBe("unknown (NOVEL)");
+        expect(sendDisabled()).toBe(true);
+        // The fee line still reports the estimate as unavailable, because it
+        // genuinely is — displayedDecimals() refuses the same missing scale.
+        // What changed is that it is no longer the ONLY thing on the screen,
+        // and no longer the only offered explanation. This is exactly how the
+        // token nothing knows the scale of already behaved.
+        expect(text("confirm-fee-amount")).toBe("Unable to estimate");
+        expect(el("confirm-fee-unknown-error").style.visibility).toBe(
+            "visible",
+        );
+    });
+
+    test("while agreeing rows leave the scale usable", async () => {
+        await fetchOntoBoth([novel("6", 5000000n)], [novel("6", 5000000n)]);
+        const txInfo = await reviewSend(NOVEL, "1.5");
+        expect(txInfo.tokenDecimals).toBe(6);
+        expect(txInfo.tokenBalance).toBe("5.0");
+        confirmTx.show(txInfo);
+        await settle();
+        expect(text("confirm-balance")).toBe("5.0 NOVEL");
+        expect(errors()).toBe("");
+        expect(sendDisabled()).toBe(false);
+    });
+});
+
+describe("the confirmation screen tells an unknown balance from a zero one", () => {
+    function txInfo(tokenBalance) {
+        return {
+            from: HOLDER,
+            to: RECIPIENT,
+            ensName: null,
+            amount: "1.5",
+            token: NOVEL,
+            balance: "1.0",
+            tokenSymbol: "NOVEL",
+            tokenBalance,
+            tokenDecimals: tokenBalance === null ? null : 18,
+        };
+    }
+
+    async function render(tokenBalance) {
+        state.wallets = [
+            {
+                name: "Wallet 1",
+                addresses: [
+                    { address: HOLDER, balance: "1.0", tokenBalances: [] },
+                ],
+            },
+        ];
+        state.selectedWallet = 0;
+        state.selectedAddress = 0;
+        confirmTx.show(txInfo(tokenBalance));
+        await settle();
+        return { balance: text("confirm-balance"), errors: errors() };
+    }
+
+    test("the balance line states unknown rather than a quantity of zero", async () => {
+        const unknown = await render(null);
+        const zero = await render("0.0");
+        expect(unknown.balance).not.toBe(zero.balance);
+        expect(unknown.balance).toBe("unknown (NOVEL)");
+        expect(zero.balance).toBe("0.0 NOVEL");
+    });
+
+    // Both hit INSUFFICIENT_TOKEN — an unknown balance is treated as nothing to
+    // spend from, which is the fail-closed side — but "you have 0.0" is a claim
+    // about the holding, and this one has no established quantity to claim.
+    test("the insufficient-balance message names the reason, not a figure", async () => {
+        const unknown = await render(null);
+        const zero = await render("0.0");
+        expect(unknown.errors).not.toBe(zero.errors);
+        expect(unknown.errors).toContain("This token&#39;s balance is unknown");
+        expect(unknown.errors).not.toContain("You have");
+        expect(zero.errors).toContain("You have 0.0 NOVEL");
+        expect(zero.errors).not.toContain("balance is unknown");
+    });
+});
+
+test("the only network these screens reached for is the Etherscan label lookup", () => {
+    for (const [url] of global.fetch.mock.calls) {
+        expect(String(url)).toMatch(/^https:\/\/etherscan\.io\/address\//);
+    }
+});
@@ -27,6 +27,14 @@ describe("generateMnemonic in a release build", () => {
        expect(constants.DEBUG).toBe(false);
    });

+    test("the test phrase folds away when DEBUG is false", () => {
+        // The release bundle is what must not carry the phrase; here, with the
+        // define absent, DEBUG_MNEMONIC is the null branch the bundler keeps,
+        // and the literal only exists in the branch it drops.
+        const { constants } = loadWallet();
+        expect(constants.DEBUG_MNEMONIC).toBeNull();
+    });
+
    test("returns fresh, valid 12-word phrases that are not the test phrase", () => {
        const { constants, wallet } = loadWallet();
Author	SHA1	Message	Date
sneak	60d2b24cd1	security: announce a fresh EIP-6963 provider UUID per page load (closes #398 ) e2e / e2e-chrome (push) Failing after 0s Details e2e / e2e-firefox (push) Failing after 0s Details check / check (push) Successful in 44s Details The provider UUID was generated once, stored in extension storage, and announced verbatim to every page on every load and across restarts, so any site — connected or not — could read a stable cross-site, cross-session identifier for the install: a supercookie contradicting the "no tracking" promise. EIP-6963 wants a fresh UUIDv4 per announcement instead. inpage.js now announces a per-load crypto.randomUUID() and persists nothing; the eip6963Uuid storage key and the AUTISTMASK_PROVIDER_UUID content-script message are removed. That key was a standalone top-level storage entry, never part of the versioned autistmask profile, so stateSchema.js and the persisted-field harness are untouched and no existing profile is affected. A jest test asserts two loads announce different UUIDv4s and that one load reuses a single UUID across re-announcements. Model: opus-4-8	2026-09-21 23:35:57 +00:00
clawbot	598de3ff1a	fix: re-enable Confirm Delete after a delete, so a second one needs no reopen (closes #335 ) check / check (push) Failing after 1s Details e2e / e2e-chrome (push) Failing after 1s Details e2e / e2e-firefox (push) Failing after 1s Details The password route disabled its Confirm Delete button before the decrypt and never re-enabled it on success, so a second delete in the same popup session found a dead button until the popup was closed and reopened. The lost-password route re-enabled its own button in its leave hook, so the two screens on the one screen behaved differently. Both routes now reset the button through the shared finishDelete(), the one path they both take, and the lost-password leave hook no longer handles it separately. Tests drive a password-route delete and a second delete in the same session; they fail against the prior head, where the button stays disabled after the first delete. Model: opus-4-8	2026-09-22 01:28:02 +02:00
clawbot	ae61792aee	chore: keep the internal view id out of the release banner (closes #375 ) e2e / e2e-chrome (push) Failing after 1s Details e2e / e2e-firefox (push) Failing after 1s Details check / check (push) Successful in 1m10s Details The debug/testnet banner appended the active view's internal id, so the user saw text like "[TESTNET] (approve-tx)" — developer vocabulary, and on the approval screen it sat directly above the carefully worded line stating what is being authorized. The view id is now gated on the compile-time DEBUG constant instead of isDebug(), so it survives only in a debug build. A testnet or the runtime debug toggle still raises the banner, but without the view id, which is what a release build shows. Model: opus-4-8	2026-09-22 00:45:06 +02:00
clawbot	a1f082d686	docs: a release procedure from a green main to tagged, packaged artifacts (closes #387 ) check / check (push) Failing after 1s Details e2e / e2e-chrome (push) Failing after 1s Details e2e / e2e-firefox (push) Failing after 1s Details Add docs/RELEASE.md, linked from README.md's Release Artifacts section, giving the release procedure as a numbered list: confirm main is green in CI, confirm the one version in package.json and the two manifests matches the intended tag, make package from a clean checkout, verify SHA256SUMS, create the annotated tag vX.Y.Z, then distribute per browser. Each step names who performs it, marks the owner-only ones, and states the check that it worked. Every repo command cited (make setup, make check, make package) exists on next; tagging and verification use standard git and coreutils, and the CRX pack line is README's own. The per-browser distribution step is written as pending the owner's choice on issue 386, with the Firefox and Chrome options named but none presented as settled. Docs only: no code or test changes. Model: opus-4-8	2026-09-21 22:00:18 +02:00
clawbot	33fa25adca	harden: bound the total network fee by gasLimit × fee, on both send paths (closes #399 ) check / check (push) Failing after 1s Details e2e / e2e-chrome (push) Failing after 1s Details e2e / e2e-firefox (push) Failing after 1s Details The two per-field ceilings in approvalVerify.js were checked independently, but the fee a validator is paid is gasLimit × fee per gas: a gas limit and a fee each under their own ceiling still multiply to thousands of ETH, which a gas-consuming contract really collects. assertWithinCeilings now also bounds that product against MAX_TOTAL_FEE (1 ETH), so both callers — populating the dApp transaction and verifying the signed artifact — refuse it with a full sentence naming the fee and the limit. The wallet's own send in confirmTx.js pinned no fee fields, so ethers filled them from the node with no bound; it now populates the transaction and runs the same check before signing, showing the same error in the confirmation screen's reserved errors box so nothing on screen moves. Model: opus-4-8	2026-09-21 21:45:34 +02:00
clawbot	2fe6447625	fix: name a tracked or explorer-known token instead of "Unknown token" (closes #323 ) check / check (push) Failing after 0s Details e2e / e2e-firefox (push) Failing after 0s Details e2e / e2e-chrome (push) Failing after 1m27s Details The approval and transaction-status screens read a token's scale from the bundled list, the tokens the user tracks, then the block explorer, but read its symbol from the bundled list alone. A token the user added by hand was scaled correctly yet labelled "Unknown token", and a non-bundled ERC-20 was carried onto the wait screen as ETH. resolveTokenSymbol() now draws the symbol through the same sources and precedence as the scale, and the ERC-20 and Uniswap swap lines both use it. A tracked or explorer-reported name stays subject to the spoof rule, so it cannot claim a bundled or native ticker. Folds in #354. Model: opus-4-8 Co-authored-by: clawbot <clawbot@noreply.example.org>	2026-09-21 21:28:06 +02:00
clawbot	2da790fbe9	fix: say a second wallet's password is separate when one is chosen (closes #374 ) check / check (push) Failing after 1s Details e2e / e2e-chrome (push) Failing after 1s Details e2e / e2e-firefox (push) Failing after 1s Details The add-wallet screen offered only "Choose a password" while each wallet keeps its own encrypted secret, so a second wallet silently accepted a password different from the first with nothing marking it as separate. A note now appears on that screen when the profile already holds a wallet, saying each wallet has its own password and this one need not match any already in use. It is shown only then — the first wallet has no other password to differ from — and is decided on screen entry, so it does not move the password fields. It promises no recovery or reset, staying consistent with the no-password-reset design. Model: opus-4-8	2026-09-21 21:11:09 +02:00
clawbot	9ac7df0128	harden: keep the test recovery phrase out of release bundles, match committed keys by content (closes #351 ) check / check (push) Failing after 1s Details e2e / e2e-chrome (push) Failing after 1s Details e2e / e2e-firefox (push) Failing after 1s Details The 12-word BIP-39 test phrase survived in every release bundle as dead text: module.exports keeps DEBUG_MNEMONIC live even though wallet.js's only use of it folds away in a release build, so it could not be tree-shaken. Putting the value itself behind the __BUILD_DEBUG__ define makes esbuild fold it to null, so no distributed bundle carries it. script/verify-build now fails a release build if the phrase appears in any emitted file, so the fold cannot silently regress; test-verify-build covers both the release failure and the debug allowance. tests/extensionId.test.js now scans the content of every tracked file for a PEM private-key header instead of matching filename extensions alone, so a key committed under an unexpected name is caught. Model: opus-4-8	2026-09-21 18:29:39 +02:00
clawbot	99292b9188	fix: honour a transaction response only for a transaction approval (closes #262 ) e2e / e2e-chrome (push) Failing after 1s Details e2e / e2e-firefox (push) Failing after 1s Details check / check (push) Successful in 1m42s Details The liveness fix this issue describes — settle 4001 on release when the window a retry would use is gone — already landed with #271. This completes the rest. AUTISTMASK_TX_RESPONSE now refuses any approval that is not a transaction approval, so a reject can no longer retire a sign or connection approval, and a signed artifact never runs the broadcast path against one — which before only failed closed by throwing deeper in. Tests pin the site-connection port's approve, reject and disconnect paths against a transaction approval broadcasting behind them: each is declined and the dApp still receives its broadcast result. Model: opus-4-8	2026-09-21 09:54:40 +02:00
clawbot	1197d2171b	fix: give every address a row of its own, so none wraps or is shortened (closes #380 ) (#381 ) check / check (push) Successful in 56s Details e2e / e2e-chrome (push) Successful in 1m51s Details e2e / e2e-firefox (push) Successful in 40s Details	2026-08-30 05:25:00 +02:00
clawbot	a098bb0c32	fix: floor malformed allowedSites, fraudContracts and selectedToken entries (closes #362 ) check / check (push) Successful in 42s Details e2e / e2e-chrome (push) Successful in 1m45s Details e2e / e2e-firefox (push) Successful in 31s Details A stored allowedSites whose value was not a list rendered a working popup and then made every subsequent save fail silently, so the user operated a wallet that persisted nothing -- worse than a blank popup, which is at least visibly broken. fraudContracts and selectedToken had the same shape: a container floored by truthiness or not at all, while its entries were dereferenced. Entries are now floored as well as containers, following the idiom #311 established, and a failed save raises a persistent banner instead of vanishing into a swallowed rejection. The per-field justifications that used to live in a hand-written header are replaced by a contract test that drives each field's hostile and falsy values through a real popup boot, so a claim about a field answers to the code rather than to prose. Its guarantee is stated narrowly and deliberately: no structural dereference on the code paths a wholly-corrupted profile takes, which is not every path a stored record takes. The paths it does not drive are named where the claim is made, and are tracked in #379.	2026-08-23 23:06:17 +02:00
clawbot	45500e66cf	fix: declare and ship toolbar icons, so neither browser renders a puzzle piece (closes #371 ) check / check (push) Successful in 33s Details e2e / e2e-chrome (push) Successful in 1m45s Details e2e / e2e-firefox (push) Successful in 32s Details Neither manifest declared any icons, so both browsers showed a generic puzzle-piece -- the first thing seen on every browser start, and how a user tells a real extension from a look-alike. Both manifests now declare 16/32/48/128, and the PNGs ship inside each browser archive rather than being left at dist/ root, which is the trap that made a naive zip incomplete before. build.js reads which icons to copy from each manifest's own icons block, so the manifest is the single source of truth and a declared-but-absent size fails the build rather than shipping a dangling reference; the packager's reference-resolver covers them independently. Manifest values are constrained before being joined into a path. The artwork is original, generated from geometry rather than traced or fetched.	2026-08-23 21:26:14 +02:00
clawbot	1b52aa1723	fix: store an absent explorer decimals as unknown instead of fabricating 18 (closes #349 ) check / check (push) Successful in 34s Details e2e / e2e-chrome (push) Successful in 1m45s Details e2e / e2e-firefox (push) Successful in 30s Details parseInt(decimals \|\| "18") ran before writing stored tokenBalances[].decimals, so an explorer reporting no decimals produced a fabricated 18 indistinguishable from a real one at read time. That defeated the resolve-or-refuse guarantees of #306 and #340: their refusal paths were intact but never fired, because the guess was laundered upstream of them. An absent scale is now stored as unknown, and a holding whose scale nothing knows carries a null balance -- unknown, never zero -- with six reader sites saying so rather than printing 0.0000. The Send screen resolves the display scale rather than reading the stored one, so a bundled token whose explorer row omits decimals still sends; when the scale cannot be resolved the stored quantity is withdrawn too, so the user is told the balance is unknown rather than only that the fee failed. Existing fabricated 18s cannot be told apart retroactively and are replaced wholesale on the next balance refresh. An explorer-sourced scale stays trusted -- only fabrication is removed; the reasoning is recorded on the issue.	2026-08-23 21:19:04 +02:00