harden: make the background physically unable to read the shared state singleton (closes #324)

Five defects traced to one fact: src/background/index.js read and wrote the
module-level `state` singleton in src/shared/state.js, which the MV3 service
worker never populates and which answered an unpopulated read out of
DEFAULT_STATE in silence. Every previous fix added a loadState() before the
access, and that is what produced the fifth: a load detaches the objects an
in-flight handler is holding.

So the reachability goes rather than a sixth call site.

The background now has its own storage layer, src/background/state.js:
getState() is a detached, normalized per-call read, and updateState() is a
queued read-modify-write whose read is one storage round trip ahead of its
write. Nothing in the background holds an in-memory copy of the profile.

- Every handler takes one snapshot and answers from it, including the address
  it names: activeAddressOf(s) replaced a second, later storage read that
  could disagree with the first.
- wallet_switchEthereumChain applies applyChainSwitchFields() (split out of
  chainSwitch.js, which keeps the singleton path for the popup) inside
  updateState() instead of calling onChainSwitch() on the singleton.
- The remembered site decision is a read-modify-write, not a load-mutate-save
  around a prompt the user takes seconds to answer.
- backgroundRefresh() refreshes a private copy of the wallets and applies the
  balances that came back by address, so it never publishes an object other
  in-flight work holds, and a wallet added or deleted during the round trip
  survives its write.
- The transaction attempt takes its chain id and its endpoint from the same
  snapshot. They used to come from different moments, so a chain switch
  committed in between moved the endpoint under an artifact already verified
  against the old chain.

getProvider(rpcUrl, networkId) now REQUIRES the network id and validates it
against networks.js. That closes the cold-worker wrong-chain send at its shape
rather than at one call site: the hint used to default to currentNetwork() off
the unpopulated singleton, so the endpoint was the user's chain and ethers
fixed chainId at 0x1, and the wallet's own verifySignedTx then refused every
non-mainnet dApp send. refreshBalances(), lookupTokenInfo(), scanForAddresses()
and resolveEnsName() carry the id through; balances.js no longer requires
state.js at all.

The prohibition is enforced mechanically, not by review, and it is enforced by
the bundler rather than by a guess at what the bundler does. build.js keeps a
FORBIDDEN_INPUTS table of modules an entry point's bundle may not contain, and
assertNoForbiddenInputs() fails the build when esbuild's metafile reports
src/shared/state.js as an input of a background bundle, naming the import chain
from the metafile's own graph. That is the resolution the shipped bundle was
built from, so no specifier syntax, no hop and no resolution rule can slip past
it; Dockerfile:42 runs make build, so it holds in CI. A FORBIDDEN_INPUTS key
that matches no bundled entry point also fails, so the table cannot rot into a
vacuous pass.

A custom ESLint rule walks the CommonJS require graph from every src/background/
file and reports the same thing in the editor, before a full bundle. It matches
specifiers textually, so it is best-effort fast feedback and not the guarantee —
two earlier revisions of it shipped holes (a template literal, a dynamic
import(), a comment inside the call, a directory resolved through package.json
main). Those are covered now and pinned by
tests/backgroundStateLintRule.test.js, and the next divergence between a
hand-rolled matcher and a real bundler is caught by the build instead. A
computed specifier (require("../shared/" + "state")) is deliberately not
matched: esbuild cannot resolve it either, so it never reaches the bundle.

Reading a persisted field of the singleton before any load now throws
StateNotLoadedError instead of serving DEFAULT_STATE.

Test stubs: chrome.storage.local is a serialization boundary, and eight files
stubbed it with an aliasing get, so the object a module held and the object
"storage" held were one object — an assertion could pass on a build that never
wrote anything. Every test that drives real persistence now goes through
tests/support/storageStub.js, which structured-clones in both directions.

closes #320

TODO.md

@@ -76,6 +76,17 @@ but the review is broader than any of them.
   of structured-cloning, which could let an assertion pass on a build that never
   wrote anything; every test that drives real persistence now goes through
   `tests/support/storageStub.js`.
+- 2026-08-23: A swap always names its output token
+  ([#346](https://git.eeqj.de/sneak/AutistMask/issues/346)). The `Token Out`
+  detail line in `src/shared/uniswap.js` was pushed only when a symbol was
+  known, so a swap whose output token is absent from the bundled list — every
+  newly listed token — showed a `Min. received` figure with nothing saying what
+  was being received. The line is now keyed on the token's address and falls
+  back to it when there is no symbol, exactly as the `Token In` line already
+  did. It composes with the unknown-scale refusal from
+  [#340](https://git.eeqj.de/sneak/AutistMask/issues/340): the address says
+  which token, the base-unit figure says how much and states that the scale is
+  unknown.
 - 2026-08-23: The swap approval screen no longer guesses 18 decimals for a token
   outside the bundled list
   ([#340](https://git.eeqj.de/sneak/AutistMask/issues/340)). `tokenInfo()` in

src/shared/uniswap.js

@@ -496,20 +496,23 @@ function decode(data, toAddress, sources) {
             });
         }
 
-        if (outSymbol) {
-            if (outInfo.address) {
-                const label = outSymbol
-                    ? outSymbol + " (" + outputToken + ")"
-                    : outputToken;
-                details.push({
-                    label: "Token Out",
-                    value: label,
-                    address: outputToken,
-                    isToken: true,
-                });
-            } else {
-                details.push({ label: "Token Out", value: outSymbol });
-            }
+        // Keyed on the address, not the symbol: a token absent from the
+        // bundled list has no symbol, and gating the line on one dropped it
+        // entirely, leaving a Min. received figure with nothing saying what is
+        // being received. The Token In line above already falls back to the
+        // address; this does the same.
+        if (outInfo.address) {
+            const label = outSymbol
+                ? outSymbol + " (" + outInfo.address + ")"
+                : outInfo.address;
+            details.push({
+                label: "Token Out",
+                value: label,
+                address: outInfo.address,
+                isToken: true,
+            });
+        } else if (outSymbol) {
+            details.push({ label: "Token Out", value: outSymbol });
         }
 
         if (minOutput !== null && minOutput !== undefined) {

tests/uniswapTokenOut.test.js

@@ -0,0 +1,107 @@
+// The output token of a swap, as the dApp approval screen names it.
+//
+// Issue #346: the `Token Out` detail line in `src/shared/uniswap.js` was
+// pushed only `if (outSymbol)`, and a token absent from the bundled list has
+// no symbol. The line was therefore dropped entirely for exactly that
+// population — which is every newly listed token — leaving a `Min. received`
+// figure with nothing on the screen saying what is being received. The
+// `Token In` line already falls back to the address; the rule asserted here is
+// that the output side does too, always.
+
+const { AbiCoder, Interface, getAddress } = require("ethers");
+const uniswap = require("../src/shared/uniswap");
+const { unknownDecimalsAmount } = require("../src/shared/approvalAmount");
+
+const ROUTER = "0x66a9893cc07d91d95644aedd05d03f95e1dba8af";
+const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
+// In the bundled list, at 18 decimals.
+const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+// Outside it, as every newly listed token is. Checksummed, because that is
+// the form the decoder gets back from the ABI decode and puts on the line.
+const NOVEL_OUT = getAddress("0xd0d0000000000000000000000000000000000d0d");
+
+const HALF_WETH = 500000000000000000n;
+// 1,000.00 of a 6-decimal token.
+const THOUSAND_AT_SIX = 1000000000n;
+
+const coder = AbiCoder.defaultAbiCoder();
+const routerIface = new Interface([
+    "function execute(bytes commands, bytes[] inputs, uint256 deadline)",
+]);
+
+// A V2_SWAP_EXACT_IN (command 0x08) execute() call.
+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,
+    ]);
+}
+
+// An UNWRAP_WETH (command 0x0c) execute() call: the output side is native ETH,
+// which has no contract address to name.
+function unwrapData() {
+    return routerIface.encodeFunctionData("execute", [
+        "0x0c",
+        [coder.encode(["address", "uint256"], [RECIPIENT, HALF_WETH])],
+        9999999999n,
+    ]);
+}
+
+function detail(data, label, sources) {
+    const decoded = uniswap.decode(data, ROUTER, sources || {});
+    return decoded.details.find((d) => d.label === label);
+}
+
+describe("a swap to a token absent from the bundled list", () => {
+    const data = () => swapData(WETH, HALF_WETH, NOVEL_OUT, THOUSAND_AT_SIX);
+
+    test("still renders a Token Out line, naming the address", () => {
+        const out = detail(data(), "Token Out");
+        expect(out).toBeDefined();
+        expect(out.value).toBe(NOVEL_OUT);
+        expect(out.address).toBe(NOVEL_OUT);
+        expect(out.isToken).toBe(true);
+    });
+
+    test("names the address alongside the unknown-scale refusal", () => {
+        // The same population hits both: no symbol, and no scale either. The
+        // address says which token, the base units say how much and admit the
+        // scale is unknown — neither line silently means something else.
+        expect(detail(data(), "Token Out").value).toBe(NOVEL_OUT);
+        expect(detail(data(), "Min. received").value).toBe(
+            unknownDecimalsAmount(THOUSAND_AT_SIX),
+        );
+    });
+
+    test("names the address when the scale is known but the symbol is not", () => {
+        const sources = {
+            trackedTokens: [
+                { address: NOVEL_OUT, symbol: "NOVEL", decimals: 6 },
+            ],
+        };
+        expect(detail(data(), "Token Out", sources).value).toBe(NOVEL_OUT);
+        expect(detail(data(), "Min. received", sources).value).toBe(
+            "1000.0000",
+        );
+    });
+});
+
+describe("the output tokens that already had a line keep it unchanged", () => {
+    test("a bundled token is named by symbol and address", () => {
+        const data = swapData(NOVEL_OUT, THOUSAND_AT_SIX, WETH, HALF_WETH);
+        const out = detail(data, "Token Out");
+        expect(out.value).toBe("WETH (" + WETH + ")");
+        expect(out.address).toBe(WETH);
+    });
+
+    test("an unwrap to native ETH is named ETH, with no address", () => {
+        const out = detail(unwrapData(), "Token Out");
+        expect(out.value).toBe("ETH");
+        expect(out.address).toBeUndefined();
+    });
+});