fix: a slow answer to an approval still reaches the site (closes #540)

Chrome stopped the background worker about six minutes after a site's
request even with the approval window open, and the approval and the
site's waiting request went with it. Every approval is now added through
addPendingApproval(), which starts a timer in the worker that calls
runtime.getPlatformInfo() every 20 seconds while any approval is
pending; Chrome counts each call as activity.

tests/e2e/slowApproval.js, run by make test-e2e, leaves a transaction
and a signature approval open for seven minutes in minimized windows and
requires the site to receive both results. It drives Chromium over the
DevTools pipe because Playwright keeps DevTools attached to the worker.
Its loopback dApp server, shared with the Firefox suite, moves to
tests/e2e/dapp.js.

Model: opus-5-5

.gitea/workflows/e2e.yml

@@ -35,10 +35,10 @@ on: [push]
 jobs:
     e2e-chrome:
         runs-on: ubuntu-latest
-        # Bounds the image build, a cold cache included, and both Chrome
+        # Bounds the image build, a cold cache included, and the three Chrome
         # programs, so a hung browser frees the shared runner. README.md
         # "In CI" has the measured times.
-        timeout-minutes: 20
+        timeout-minutes: 40
         steps:
             # actions/checkout v4.2.2, 2026-02-22
             - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683

README.md

@@ -542,6 +542,28 @@ one profile yields a single extension id, not two: Chrome does not load a second
 copy of an id it already has. The assertions are annotated as observations, so a
 Chrome that ever changes this fails the run instead of passing it.
 
+Last, `make test-e2e` runs `tests/e2e/slowApproval.js`, which leaves a
+transaction approval and a signature approval open for seven minutes with both
+windows minimized, then restores and approves both and requires the site to
+receive the hash of the transaction the stub node received and a signature that
+recovers to the address. Before the background worker kept itself running while
+an approval is pending, Chrome stopped it about six minutes in and neither
+request was ever answered
+([#540](https://git.eeqj.de/sneak/AutistMask/issues/540)). The windows are
+minimized through the DevTools protocol (`Browser.setWindowBounds`), and the run
+fails unless both pages then report themselves hidden: Chrome slows a hidden
+page's timers to once a minute, so anything the window did to keep the worker
+running would fail here. It is its own program and does not use Playwright:
+Playwright keeps DevTools attached to the background worker, and Chrome never
+stops a worker DevTools is attached to, so no wait in the suite above can show
+the worker stopping. It starts Chromium itself, speaks the DevTools protocol
+over `--remote-debugging-pipe`, and attaches to pages only. Before raising the
+approvals it requires the worker to stop on its own with nothing pending, so a
+run in which something else keeps the worker running fails. The site is
+connected and the RPC endpoint set through the extension's own screens, against
+the loopback dApp page and stub node the Firefox suite also uses
+(`tests/e2e/dapp.js`). Unlike the suite above, it does not fail on page errors.
+
 ### Firefox (`make test-e2e-firefox`)
 
 `make test-e2e-firefox` builds `dist/firefox/` and drives the **real popup in a
@@ -555,9 +577,10 @@ background page and approval windows.
 
 The suite lives in `tests/e2e/firefox/`. Its WebDriver client (`driver.js`) has
 **no npm dependencies at all**: it is built on global `fetch` and
-`child_process` against geckodriver's HTTP API. The dApp fixture (`dapp.js`) and
-the assertions do use `ethers`, and have to — a signature is recovered in the
-runner rather than believed from the extension, and the stub node has to answer
+`child_process` against geckodriver's HTTP API. The dApp fixture
+(`tests/e2e/dapp.js`, shared with `tests/e2e/slowApproval.js`) and the
+assertions do use `ethers`, and have to — a signature is recovered in the runner
+rather than believed from the extension, and the stub node has to answer
 `eth_sendRawTransaction` with the hash `ethers` computes for the artifact it
 sent, or `provider.broadcastTransaction()` refuses the answer.
 
@@ -663,16 +686,16 @@ Three limits are worth knowing, all real differences from the Chrome suite:
 - **Almost nothing is stubbed, which inverts the coverage of network-dependent
   code.** The container still runs with `--network none`, so the run is offline
   and no request can escape. The one thing it can reach is the loopback fixture
-  in `tests/e2e/firefox/dapp.js`, which serves the dApp page and a JSON-RPC node
-  and which the extension's `rpcUrl` is pointed at for the dApp steps; a
-  JSON-RPC method that fixture does not model fails the run rather than
-  answering `null`. Everything else, Blockscout and the price feed among it, has
-  no fixture and simply fails, and the extension swallows its own fetch
-  failures, so only the _failure_ branches of that code are ever executed. A
-  `ReferenceError` in the success path of `renderTransactions`, or of price
-  rendering, passes this suite green. The offline run is also weaker than the
-  Chrome suite's interception for those calls: it proves nothing got out, but it
-  cannot report which requests were attempted.
+  in `tests/e2e/dapp.js`, which serves the dApp page and a JSON-RPC node and
+  which the extension's `rpcUrl` is pointed at for the dApp steps; a JSON-RPC
+  method that fixture does not model fails the run rather than answering `null`.
+  Everything else, Blockscout and the price feed among it, has no fixture and
+  simply fails, and the extension swallows its own fetch failures, so only the
+  _failure_ branches of that code are ever executed. A `ReferenceError` in the
+  success path of `renderTransactions`, or of price rendering, passes this suite
+  green. The offline run is also weaker than the Chrome suite's interception for
+  those calls: it proves nothing got out, but it cannot report which requests
+  were attempted.
 - **The site-connection prompt always opens in a window of its own.** The
   profile turns off `extensions.openPopupWithoutUserGesture.enabled`, so
   `src/background/index.js` falls back from the toolbar popup, which WebDriver
@@ -722,11 +745,13 @@ installing Firefox, geckodriver and their system libraries. Both scripts now
 build their image with `--no-cache`, so every run pays the cold figure. Those
 `e2e-chrome` runs predate the cases that wait in real time for a receipt to end
 in error. `make test-e2e` took 3m51s locally with its image cached, so with the
-image rebuilt every run, an `e2e-chrome` run comes to about seven minutes.
+image rebuilt every run, an `e2e-chrome` run comes to about seven minutes. The
+approvals left open for seven minutes (`tests/e2e/slowApproval.js`) add about
+eight more, so about fifteen.
 
 Each e2e job has a `timeout-minutes` cap, so a hung build or browser ends the
 job instead of holding the shared runner: `e2e-firefox` 15 minutes and
-`e2e-chrome` 20, each over two and a half times the job's slowest cold run. A
+`e2e-chrome` 40, each over two and a half times the job's slowest cold run. A
 job that reaches its cap has hung; read it as a hang, not as a slow run to
 retry. The `check` job has no cap: `.gitea/workflows/check.yml` is the canonical
 copy from `sneak/prompts`, kept byte-identical.
@@ -821,8 +846,22 @@ on the next event. Two consequences shape every recurring job in the background:
   service worker at all — the one remaining user of it, `src/shared/ens.js`,
   runs only in the popup and is marked as such.
 
-The job also carries a freshness guard, and a guard must never be timed to the
-alarm period it gates. The guard is measured from the moment the last run
+Pending approvals are the exception: an approval waiting for the user, and the
+site's request waiting on it, live only in the worker's memory, and only the
+worker that received the request can answer it. Left alone, Chrome stopped the
+worker about six minutes after a site's request even with the approval window
+still open, and the user's answer then reached nobody. So the worker keeps
+itself running while any approval is pending: every approval is added through
+`addPendingApproval()`, which starts a `setInterval` that calls
+`runtime.getPlatformInfo()` every 20 seconds, and Chrome counts each extension
+call as activity. The timer stops itself once nothing is pending, and the worker
+then stops as it otherwise would. The timer is the worker's own, so it does not
+depend on the approval window being visible; a timer in the window would,
+because Chrome slows a hidden page's timers to once a minute. A worker that
+stops for another reason, a crash say, still loses the approvals open in it.
+
+The balance refresh carries a freshness guard, and a guard must never be timed
+to the alarm period it gates. The guard is measured from the moment the last run
 finished, which is one run-duration after the alarm that started it, so a guard
 of exactly one period vetoes the very next tick and the real cadence becomes two
 periods. The balance refresh guard exists to skip work an open popup has already
@@ -1125,18 +1164,14 @@ read:
 
 The swap's `Token In` and `Token Out` lines name a currency, not an amount; each
 reads `Unknown (not named in the calldata)` when the decoder found no token for
-that side, or `Unknown (could not be decoded)` instead when a V4 swap action in
-the transaction could not be read (see Transaction Decoding below). A V4 step
-whose swap action could not be read still sets each side as a swap step does,
-and a side its `SETTLE` or `TAKE` did not name is then unknown: no other step's
-token or figure is shown for it. An `UNWRAP_WETH` step makes `Token Out` ETH
-only when the output side is WETH, on mainnet or Sepolia, or when no step set
-the output side; a WETH `Min. received` figure then reads in ETH. Otherwise
-`Token Out` and `Min. received` keep the output side's own token and figure,
-whether the swap was paid in ETH or in a token: a V2 exact-out swap that buys
-USDC and then unwraps the WETH it did not spend shows USDC. The token permission
-warning on the signature screen has its own amount wording, including `Unknown`;
-the SignApproval section below describes it.
+that side. An `UNWRAP_WETH` step makes `Token Out` ETH only when the output side
+is WETH, on mainnet or Sepolia, or when no step set the output side; a WETH
+`Min. received` figure then reads in ETH. Otherwise `Token Out` and
+`Min. received` keep the output side's own token and figure, whether the swap
+was paid in ETH or in a token: a V2 exact-out swap that buys USDC and then
+unwraps the WETH it did not spend shows USDC. The token permission warning on
+the signature screen has its own amount wording, including `Unknown`; the
+SignApproval section below describes it.
 
 The swap's `Deadline` line is the router's deadline as a UTC date and time, e.g.
 `2026-02-27 08:25:51`. A JavaScript date reaches only to 275760-09-13 00:00:00
@@ -1698,11 +1733,7 @@ view would leave a wallet one click from deletion.
 - **When**: Transaction has been broadcast, waiting for on-chain confirmation.
 - **Elements**:
     - "Transaction Broadcast" heading (no back button — tx is irreversible)
-    - Amount + symbol. For a swap the approval screen showed no `Amount` for,
-      such as one whose V4 swap action could not be read or a V4 exact-out swap,
-      `Unknown (could not be decoded)` with no symbol, not the transaction's ETH
-      value. When that swap's `Token In` is `ETH (native)`, the transaction's
-      ETH value in the network's currency, as for any other transaction
+    - Amount + symbol
     - To: color dot + full address + etherscan link; for a contract creation,
       which has no recipient, "This transaction creates a new contract. It has
       no recipient." instead
@@ -1749,9 +1780,7 @@ view would leave a wallet one click from deletion.
 - **When**: Transaction broadcast failed, or timed out waiting for confirmation.
 - **Elements**:
     - "Transaction Failed" heading
-    - Amount + symbol, or for a swap the approval screen showed no `Amount` for,
-      the same as on WaitTx: `Unknown (could not be decoded)`, unless its
-      `Token In` is `ETH (native)`
+    - Amount + symbol
     - To: color dot + full address + etherscan link, or for a contract creation
       the same sentence as on WaitTx
     - Error message (dashed border box)
@@ -2757,11 +2786,7 @@ Currently supported:
   or recipient, and amount.
 - **Uniswap Universal Router**: `execute()` calls — shows swap direction (e.g.
   "Swap USDT → ETH"), token addresses, amounts, execution steps, and deadline.
-  Decodes Permit2, V2/V3/V4 swaps, wrap/unwrap, and balance checks. A V4 swap
-  action is read only in the parameter shape deployed on mainnet and Sepolia,
-  not in the newer one on `v4-periphery` `main`, which adds a `minHopPriceX36`
-  field. An action in any other shape is not read, and its step is listed as
-  `V4 Swap (could not be decoded)`.
+  Decodes Permit2, V2/V3/V4 swaps, wrap/unwrap, and balance checks.
 
 ### Non-Goals Forever
 

script/test-e2e

@@ -97,6 +97,18 @@ main() {
         -e HOME=/tmp \
         "$(cat "$IIDFILE")" \
         node tests/e2e/storagePartition.js
+
+    # Approvals left open for seven minutes in minimized windows, past the
+    # point where Chrome stopped the background worker when nothing kept it
+    # running. Its own program, without Playwright: Playwright keeps DevTools
+    # attached to the worker, and Chrome never stops a worker DevTools is
+    # attached to. It reaches nothing but its own loopback server.
+    echo "Running the approvals left open for seven minutes..."
+    docker run --rm \
+        --ipc=host \
+        -e HOME=/tmp \
+        "$(cat "$IIDFILE")" \
+        node tests/e2e/slowApproval.js
 }
 
 main "$@"

src/background/index.js

@@ -44,6 +44,7 @@ const {
 
 const {
     actionApi,
+    getPlatformInfo,
     runtimeApi,
     tabsQuery,
     tabsSendMessage,
@@ -67,6 +68,33 @@ const connectedSites = {};
 // Pending approval requests: { id: { origin, resolve } }
 const pendingApprovals = {};
 
+// An approval, and the site's request waiting on it, exist only in this
+// worker's memory. Left alone, Chrome stopped the worker about six minutes
+// after the site's request while the user was still deciding, and the approval
+// was lost with it. Chrome counts an extension call as activity, so while any
+// approval is pending this worker makes one every 20 seconds, inside Chrome's
+// 30-second idle limit. It is the worker's own timer, so it runs whether or not
+// the approval window is visible, and it stops itself once nothing is pending.
+let keepRunningTimer = null;
+
+// Add an approval waiting for the user, and start the timer above if it is not
+// running. This is the ONLY place an approval is added, as settleApproval() is
+// the only place one is removed, so every kind of approval keeps the worker
+// running while it waits.
+function addPendingApproval(approval) {
+    pendingApprovals[approval.id] = approval;
+    if (keepRunningTimer) return;
+    keepRunningTimer = setInterval(() => {
+        if (Object.keys(pendingApprovals).length === 0) {
+            clearInterval(keepRunningTimer);
+            keepRunningTimer = null;
+            return;
+        }
+        // Only the call matters; its answer is not used.
+        getPlatformInfo().catch(() => {});
+    }, 20000);
+}
+
 // One transaction approval at a time, wallet-wide.
 //
 // The transaction a site asks for is populated before its approval window
@@ -514,7 +542,7 @@ async function openApprovalWindow(id) {
 function requestApproval(origin) {
     return new Promise((resolve) => {
         const id = crypto.randomUUID();
-        pendingApprovals[id] = { id, origin, resolve, type: "site" };
+        addPendingApproval({ id, origin, resolve, type: "site" });
 
         if (actionNs && typeof actionNs.openPopup === "function") {
             showInToolbarPopup(id);
@@ -557,14 +585,14 @@ function showInToolbarPopup(id) {
 function requestTxApproval(origin, approvedTx, approvedFrom, slot) {
     return new Promise((resolve) => {
         const id = crypto.randomUUID();
-        pendingApprovals[id] = {
+        addPendingApproval({
             id,
             origin,
             approvedTx,
             approvedFrom,
             resolve,
             type: "tx",
-        };
+        });
         if (slot) slot.approvalId = id;
 
         openApprovalWindow(id);
@@ -578,14 +606,14 @@ function requestTxApproval(origin, approvedTx, approvedFrom, slot) {
 function requestSignApproval(origin, signParams, approvedFrom) {
     return new Promise((resolve) => {
         const id = crypto.randomUUID();
-        pendingApprovals[id] = {
+        addPendingApproval({
             id,
             origin,
             signParams,
             approvedFrom,
             resolve,
             type: "sign",
-        };
+        });
 
         openApprovalWindow(id);
     });
@@ -598,14 +626,14 @@ function requestSignApproval(origin, signParams, approvedFrom) {
 function requestNetworkApproval(origin, currentNetworkId, requestedNetworkId) {
     return new Promise((resolve) => {
         const id = crypto.randomUUID();
-        pendingApprovals[id] = {
+        addPendingApproval({
             id,
             origin,
             currentNetworkId,
             requestedNetworkId,
             resolve,
             type: "network",
-        };
+        });
 
         openApprovalWindow(id);
     });

src/popup/views/approval.js

@@ -298,23 +298,6 @@ function showTxApproval(details) {
                 sources,
             );
         }
-        // A swap the decoder read no amount for, such as one whose V4 swap
-        // action could not be read or a V4 exact-out swap. The wait and error
-        // screens say the amount could not be decoded, with no currency after
-        // it, rather than show the transaction's ETH value as the amount. A
-        // swap paid in native ETH keeps that value: it is the ETH the swap
-        // pays (for an exact-out swap, the most it pays), not a figure that
-        // had to be read from the calldata.
-        const tokenIn = decoded.details.find((d) => d.label === "Token In");
-        if (
-            tokenIn &&
-            tokenIn.value !== "ETH (native)" &&
-            !decoded.details.some((d) => d.label === "Amount")
-        ) {
-            pendingTxDetails.amount = "Unknown (could not be decoded)";
-            pendingTxDetails.token = null;
-            pendingTxDetails.tokenSymbol = null;
-        }
     }
 
     // Carry decoded calldata info through to success/error views

src/popup/views/txStatus.js

@@ -91,17 +91,12 @@ function startWait(txInfo, txHash, broadcastTime, pollNow) {
     // native currency of txInfo.chainId, the network the transaction was sent
     // on, not the active network's: the active network can change, in
     // Settings or when the user approves a site's request, while this screen
-    // is open or before a later popup resumes it. A null token is a swap whose
-    // amount was not decoded (see showTxApproval() in approval.js): the amount
-    // says so, and no symbol follows it.
-    let symbol = "";
-    if (txInfo.token === "ETH") {
-        symbol = nativeCurrencyByChainId(txInfo.chainId);
-    } else if (txInfo.token !== null) {
-        symbol = displaySymbol(txInfo.tokenSymbol || "?");
-    }
-    $("wait-tx-summary").textContent =
-        txInfo.amount + (symbol ? " " + symbol : "");
+    // is open or before a later popup resumes it.
+    const symbol =
+        txInfo.token === "ETH"
+            ? nativeCurrencyByChainId(txInfo.chainId)
+            : displaySymbol(txInfo.tokenSymbol || "?");
+    $("wait-tx-summary").textContent = txInfo.amount + " " + symbol;
     $("wait-tx-to").innerHTML = toAddressHtml(txInfo.to);
     $("wait-tx-hash").innerHTML = txHashHtml(txHash);
     attachCopyHandlers("view-wait-tx");
@@ -236,13 +231,10 @@ function restoreWait() {
 function showSuccess(txInfo, txHash, blockNumber) {
     endWait();
 
-    // As on the wait screen, a null token has no symbol.
-    let symbol = "";
-    if (txInfo.token === "ETH") {
-        symbol = nativeCurrencyByChainId(txInfo.chainId);
-    } else if (txInfo.token !== null) {
-        symbol = displaySymbol(txInfo.tokenSymbol || "?");
-    }
+    const symbol =
+        txInfo.token === "ETH"
+            ? nativeCurrencyByChainId(txInfo.chainId)
+            : displaySymbol(txInfo.tokenSymbol || "?");
     state.viewData = {
         amount: txInfo.amount,
         symbol: symbol,
@@ -302,8 +294,7 @@ function renderSuccess() {
     } else {
         summarySection.classList.remove("hidden");
         toSection.classList.remove("hidden");
-        $("success-tx-summary").textContent =
-            d.amount + (d.symbol ? " " + d.symbol : "");
+        $("success-tx-summary").textContent = d.amount + " " + d.symbol;
         $("success-tx-to").innerHTML = toAddressHtml(d.to);
     }
 
@@ -326,13 +317,10 @@ function renderSuccess() {
 function showError(txInfo, txHash, message) {
     endWait();
 
-    // As on the wait screen, a null token has no symbol.
-    let symbol = "";
-    if (txInfo.token === "ETH") {
-        symbol = nativeCurrencyByChainId(txInfo.chainId);
-    } else if (txInfo.token !== null) {
-        symbol = displaySymbol(txInfo.tokenSymbol || "?");
-    }
+    const symbol =
+        txInfo.token === "ETH"
+            ? nativeCurrencyByChainId(txInfo.chainId)
+            : displaySymbol(txInfo.tokenSymbol || "?");
     state.viewData = {
         amount: txInfo.amount,
         symbol: symbol,
@@ -346,8 +334,7 @@ function showError(txInfo, txHash, message) {
 function renderError() {
     const d = state.viewData;
     if (!d || !d.message) return;
-    $("error-tx-summary").textContent =
-        d.amount + (d.symbol ? " " + d.symbol : "");
+    $("error-tx-summary").textContent = d.amount + " " + d.symbol;
     $("error-tx-to").innerHTML = toAddressHtml(d.to);
     $("error-tx-message").textContent = d.message;
 

src/shared/browserApi.js

@@ -145,6 +145,14 @@ function sendMessage(message) {
     return invoke(runtimeApi(), "sendMessage", message);
 }
 
+/**
+ * @returns {Promise<Object>} the operating system and processor the browser
+ *     runs on.
+ */
+function getPlatformInfo() {
+    return invoke(runtimeApi(), "getPlatformInfo");
+}
+
 /**
  * Send a message nobody is expected to answer, and swallow the fact that
  * nobody did.
@@ -262,6 +270,7 @@ module.exports = {
     actionApi,
     alarmsApi,
     extensionApi,
+    getPlatformInfo,
     hasBrowserNamespace,
     notify,
     runtimeApi,

src/shared/uniswap.js

@@ -53,11 +53,6 @@ function formatAmount(raw, decimals) {
 // on a scale — not as a token name, and not as a quantity.
 const UNNAMED_CURRENCY = "Unknown (not named in the calldata)";
 
-// The same refusal when a V4 swap action could not be read (see
-// decodeExactly()). That action names both of its currencies, so saying the
-// calldata did not name one would be false.
-const UNDECODED_CURRENCY = "Unknown (could not be decoded)";
-
 // Explicit presence, never truthiness. Every gate in this file that guards a
 // decoded value goes through here: an address is never falsy once set, but an
 // amount of 0n is, and a gate that cannot tell a genuine zero from an absent
@@ -300,24 +295,6 @@ function v4ExactInAmount(raw) {
     return raw === 0n ? OPEN_DELTA : raw;
 }
 
-// The V4 swap actions are read only in the parameter structs V4Router has
-// deployed on mainnet and Sepolia. v4-periphery `main` has since added a
-// `minHopPriceX36` field to all four (`src/interfaces/IV4Router.sol`), and
-// reading a shape nobody has deployed would be guessing. ethers alone would
-// read the newer structs anyway: it takes whatever word sits where a
-// deployed field would be, ignores bytes left over, and holds back an error
-// in a field until that field is used. The newer multi-hop exact-in struct
-// then yields the offset of its hop-price array as `amountIn`. So a decode
-// counts only when encoding the result again gives back the same bytes;
-// otherwise this throws, and decodeV4Swap() marks the step as not decoded.
-function decodeExactly(types, data) {
-    const decoded = coder.decode(types, data);
-    if (coder.encode(types, decoded) !== data) {
-        throw new Error("Not in the deployed V4 parameter shape.");
-    }
-    return decoded;
-}
-
 // Decode V4_SWAP (command 0x10) input bytes.
 // The input is ABI-encoded as (bytes actions, bytes[] params).
 // We extract token addresses from SETTLE (input) and TAKE (output) sub-actions,
@@ -332,10 +309,6 @@ function decodeV4Swap(input) {
         let takeToken = null;
         let amountIn = null;
         let amountOutMin = null;
-        // Set when a swap action's parameters are not in the deployed shape
-        // (see decodeExactly()), so nothing was read from that action. SETTLE
-        // and TAKE may still name both currencies.
-        let swapUndecoded = false;
 
         for (let i = 0; i < actions.length; i++) {
             const actionId = actions[i];
@@ -364,7 +337,7 @@ function decodeV4Swap(input) {
                         //   tuple(address,uint24,int24,address,bytes)[] path,
                         //   uint128 amountIn, uint128 amountOutMin)
                         try {
-                            const s = decodeExactly(
+                            const s = coder.decode(
                                 [
                                     "tuple(address,tuple(address,uint24,int24,address,bytes)[],uint128,uint128)",
                                 ],
@@ -382,13 +355,13 @@ function decodeV4Swap(input) {
                                 amountOutMin = s[0][3];
                             }
                         } catch {
-                            swapUndecoded = true;
+                            // Fall through — SETTLE/TAKE will provide tokens
                         }
                     } else {
                         // ExactInputSingleParams: (tuple(address,address,uint24,int24,address) poolKey,
                         //   bool zeroForOne, uint128 amountIn, uint128 amountOutMin, bytes hookData)
                         try {
-                            const s = decodeExactly(
+                            const s = coder.decode(
                                 [
                                     "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
                                 ],
@@ -411,7 +384,7 @@ function decodeV4Swap(input) {
                                 amountOutMin = s[0][3];
                             }
                         } catch {
-                            swapUndecoded = true;
+                            // Fall through
                         }
                     }
                 } else if (
@@ -420,7 +393,7 @@ function decodeV4Swap(input) {
                 ) {
                     if (actionId === V4_SWAP_EXACT_OUT) {
                         try {
-                            const s = decodeExactly(
+                            const s = coder.decode(
                                 [
                                     "tuple(address,tuple(address,uint24,int24,address,bytes)[],uint128,uint128)",
                                 ],
@@ -432,11 +405,11 @@ function decodeV4Swap(input) {
                                 settleToken = path[path.length - 1][0];
                             }
                         } catch {
-                            swapUndecoded = true;
+                            // Fall through
                         }
                     } else {
                         try {
-                            const s = decodeExactly(
+                            const s = coder.decode(
                                 [
                                     "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
                                 ],
@@ -453,7 +426,7 @@ function decodeV4Swap(input) {
                                     ? poolKey[1]
                                     : poolKey[0];
                         } catch {
-                            swapUndecoded = true;
+                            // Fall through
                         }
                     }
                 }
@@ -467,7 +440,6 @@ function decodeV4Swap(input) {
             tokenOut: takeToken,
             amountIn,
             amountOutMin,
-            swapUndecoded,
         };
     } catch {
         return null;
@@ -493,7 +465,6 @@ function decode(data, toAddress, sources) {
         let minOutput = null;
         let hasUnwrapWeth = false;
         let hasV2ExactOut = false;
-        let swapUndecoded = false;
         const commandNames = [];
 
         // THE INVARIANT: an amount and the token it is counted in always come
@@ -596,20 +567,7 @@ function decode(data, toAddress, sources) {
 
                 if (cmdId === 0x10) {
                     const v4 = decodeV4Swap(inputs[i]);
-                    if (v4 && v4.swapUndecoded) {
-                        // The unread swap action named this step's currencies
-                        // and amounts, so the step is marked and still sets
-                        // both sides as a swap step does. A side its SETTLE or
-                        // TAKE did not name is set undetermined, not left to
-                        // an earlier or later step's token and figure.
-                        swapUndecoded = true;
-                        commandNames[i] += " (could not be decoded)";
-                        if (!inputEstablished) {
-                            setInput(v4.tokenIn, v4.amountIn);
-                        }
-                        outputToken = v4.tokenOut;
-                        minOutput = v4.amountOutMin;
-                    } else if (v4) {
+                    if (v4) {
                         setInputOnce(v4.tokenIn, v4.amountIn);
                         // Always update output: last swap step wins. A step
                         // that carries the Min. received figure but decoded no
@@ -633,19 +591,16 @@ function decode(data, toAddress, sources) {
             }
         }
 
-        // Resolve token info. A null token on either side means no step named
-        // a currency for it, or a V4 step whose swap action went unread left
-        // it undetermined; tokenInfo() refuses rather than calling it ETH.
-        // UNWRAP_WETH turns WETH into ETH, so it makes the output ETH when the
-        // output side is WETH, or when no step set the output side. A step
-        // whose swap action went unread did set it, to undetermined. Any other
-        // output keeps its own token and figure: a swap that buys USDC and
-        // then unwraps the WETH it did not spend receives USDC.
+        // Resolve token info. A null token on either side means the calldata
+        // named no currency for it; tokenInfo() refuses rather than calling it
+        // ETH. UNWRAP_WETH turns WETH into ETH, so it makes the output ETH
+        // when the output side is WETH, or when no step set the output side.
+        // Any other output keeps its own token and figure: a swap that buys
+        // USDC and then unwraps the WETH it did not spend receives USDC.
         const outputIsWeth =
             present(outputToken) &&
             WETH_ADDRESSES.includes(outputToken.toLowerCase());
-        const outputUnset =
-            !present(outputToken) && !present(minOutput) && !swapUndecoded;
+        const outputUnset = !present(outputToken) && !present(minOutput);
         const inInfo = tokenInfo(inputToken, sources);
         const outInfo =
             hasUnwrapWeth && (outputIsWeth || outputUnset)
@@ -685,10 +640,7 @@ function decode(data, toAddress, sources) {
             // rather than going missing or naming a token by default. Same
             // wording as the Token Out refusal below: the two sides of this
             // screen must not describe the same condition in two ways.
-            details.push({
-                label: "Token In",
-                value: swapUndecoded ? UNDECODED_CURRENCY : UNNAMED_CURRENCY,
-            });
+            details.push({ label: "Token In", value: UNNAMED_CURRENCY });
         }
 
         if (present(inputAmount)) {
@@ -751,10 +703,7 @@ function decode(data, toAddress, sources) {
             // rather than going missing or naming a token by default, and a
             // Min. received figure below it is never attached to a token the
             // calldata did not state.
-            details.push({
-                label: "Token Out",
-                value: swapUndecoded ? UNDECODED_CURRENCY : UNNAMED_CURRENCY,
-            });
+            details.push({ label: "Token Out", value: UNNAMED_CURRENCY });
         }
 
         if (present(minOutput)) {

tests/backgroundApproval.test.js

@@ -264,6 +264,7 @@ function loadBackground(options) {
                     connectListener = fn;
                 },
             },
+            getPlatformInfo: jest.fn((cb) => cb({ os: "linux" })),
             lastError: null,
         },
         windows: {
@@ -878,6 +879,45 @@ describe("one transaction approval at a time", () => {
     });
 });
 
+// Chrome stops an idle worker, and the approvals in it go with it
+// (https://git.eeqj.de/sneak/AutistMask/issues/540). tests/e2e/slowApproval.js
+// shows the worker kept running in Chrome; this shows the calls stop once the
+// approval is answered, so the worker can stop again. Every kind of approval is
+// added through addPendingApproval(), which starts the calls, so a transaction
+// approval stands for all of them.
+describe("the worker keeps running while an approval is pending", () => {
+    test("an extension call every 20 seconds until the approval is answered", async () => {
+        const startTimer = jest
+            .spyOn(global, "setInterval")
+            .mockImplementation(() => 1);
+        const stopTimer = jest
+            .spyOn(global, "clearInterval")
+            .mockImplementation(() => {});
+        try {
+            const bg = loadBackground();
+            const calls = global.chrome.runtime.getPlatformInfo;
+            bg.requestTx();
+            await settle();
+            expect(startTimer).toHaveBeenCalledTimes(1);
+            expect(startTimer.mock.calls[0][1]).toBe(20000);
+            const tick = startTimer.mock.calls[0][0];
+
+            tick();
+            expect(calls).toHaveBeenCalledTimes(1);
+
+            // The user closes the approval window, which rejects it.
+            bg.closeWindow(1);
+            await settle();
+            tick();
+            expect(calls).toHaveBeenCalledTimes(1);
+            expect(stopTimer).toHaveBeenCalledWith(1);
+        } finally {
+            startTimer.mockRestore();
+            stopTimer.mockRestore();
+        }
+    });
+});
+
 // A page that asks again before the user has answered its last connection or
 // signature request is refused, instead of opening one more window per call.
 describe("one connection and one signature approval per site at a time", () => {

tests/e2e/dapp.js

@@ -1,25 +1,29 @@
-// A loopback dApp origin and stub Ethereum node for the Firefox suite.
+// A loopback dApp origin and stub Ethereum node, used by the two browser
+// programs that have no Playwright to answer the browser's requests for them:
+// the Firefox suite (tests/e2e/firefox/run.js) and the Chrome program that
+// leaves approvals open for seven minutes (tests/e2e/slowApproval.js). The
+// Chrome suite in run.js answers its requests through network.js instead.
 //
 // The Firefox container runs with --network none, and the harness note in
-// driver.js records the consequence: with no http:// origin in reach, no
-// content script was ever injected, so content-script behaviour was
+// firefox/driver.js records the consequence: with no http:// origin in reach,
+// no content script was ever injected, so content-script behaviour was
 // UNVERIFIED and the dApp flows could not be driven at all.
 //
 // --network none removes every interface except loopback, and loopback is
 // enough. This serves the page and the JSON-RPC endpoint from 127.0.0.1
-// inside the same container Firefox runs in, so the dApp round trips execute
-// against a real http:// origin and the run stays as offline as it was: the
-// only reachable peer is this process.
+// inside the same container the browser runs in, so the dApp round trips
+// execute against a real http:// origin and the run stays as offline as it
+// was: the only reachable peer is this process.
 //
 // The page itself is not written twice. DAPP_HTML comes from the Chrome
-// suite's fixture, so both harnesses drive the same __dapp API and the same
-// message log.
+// suite's fixture, so every browser program drives the same __dapp API and
+// the same message log.
 //
-// Unlike driver.js this file does use ethers, and it has to: the node has to
-// answer eth_sendRawTransaction with the hash ethers computes for the
+// Unlike firefox/driver.js this file does use ethers, and it has to: the node
+// has to answer eth_sendRawTransaction with the hash ethers computes for the
 // artifact it was handed, or provider.broadcastTransaction() refuses the
-// answer, and the suite recovers signatures itself rather than believing the
-// extension's own verdict.
+// answer, and both programs recover signatures themselves rather than
+// believing the extension's own verdict.
 
 "use strict";
 
@@ -27,7 +31,7 @@ const http = require("http");
 
 const { Transaction } = require("ethers");
 
-const { DAPP_HTML } = require("../network");
+const { DAPP_HTML } = require("./network");
 
 // The same fee shape the Chrome suite uses, for the same reason: it has to
 // pass the ceilings in src/shared/approvalVerify.js and it has to leave the
@@ -170,11 +174,11 @@ async function startDappServer() {
                     const payload = JSON.stringify(handleRpcBody(body, state));
                     res.writeHead(200, {
                         "Content-Type": "application/json",
-                        // The extension fetches this from its background
-                        // page, whose origin is moz-extension://. Without CORS
-                        // the fetch fails and every transaction assertion
-                        // fails for a reason that has nothing to do with the
-                        // wallet.
+                        // In Firefox the extension fetches this from its
+                        // background page, whose origin is moz-extension://.
+                        // Without CORS the fetch fails and every transaction
+                        // assertion fails for a reason that has nothing to do
+                        // with the wallet.
                         "Access-Control-Allow-Origin": "*",
                     });
                     res.end(payload);
@@ -193,8 +197,8 @@ async function startDappServer() {
         }
 
         // An empty favicon rather than a 404: a 404 is a page error in
-        // Firefox's console under some settings, and the suite fails the run
-        // on those.
+        // Firefox's console under some settings, and the Firefox suite fails
+        // the run on those.
         if (url.pathname === "/favicon.ico") {
             res.writeHead(200, { "Content-Type": "image/x-icon" });
             res.end("");

tests/e2e/firefox/driver.js

@@ -467,7 +467,7 @@ class Driver {
 // src/background/index.js, which kills the background page outright, fails
 // the run.
 //
-// Content scripts ARE now exercised: tests/e2e/firefox/dapp.js serves a page
+// Content scripts ARE now exercised: tests/e2e/dapp.js serves a page
 // from loopback, which survives --network none, and the suite drives the
 // EIP-1193 round trips through the content script injected into it. What is
 // still unproven is the CAPTURE, not the execution — no probe has forced a

tests/e2e/firefox/run.js

@@ -17,13 +17,13 @@
 // note in driver.js), so the two backends have no common substrate to
 // abstract over. Duplicated steps do not pay for a shim; revisit if this
 // suite grows to where they do. What IS shared is the dApp page fixture
-// itself — DAPP_HTML, served here from loopback by dapp.js — so an assertion
-// about the __dapp API means the same thing on both browsers.
+// itself — DAPP_HTML, served here from loopback by tests/e2e/dapp.js — so an
+// assertion about the __dapp API means the same thing on both browsers.
 //
 // The dApp steps need an http:// origin, which --network none was thought to
 // rule out. It does not: loopback survives it, so the page and the stub node
 // are served from 127.0.0.1 inside the container and the run reaches nothing
-// but this process. See tests/e2e/firefox/dapp.js.
+// but this process. See tests/e2e/dapp.js.
 //
 // LIMITATION, and the difference from the Chrome suite worth knowing: error
 // capture here is POLL-BASED, not event-streamed. The console service is
@@ -61,7 +61,7 @@ const {
 } = require("ethers");
 
 const { ConsoleErrors, EXTENSION_ORIGIN, start, sleep } = require("./driver");
-const { startDappServer } = require("./dapp");
+const { startDappServer } = require("../dapp");
 const { STUB_COUNTERPARTY } = require("../network");
 const { NETWORKS } = require("../../../src/shared/networks");
 const {

tests/e2e/network.js

@@ -94,7 +94,7 @@ function word(value) {
 // is the real inpage provider and not a copy the harness wired up.
 //
 // DAPP_HTML below is exported and served verbatim by the Firefox suite too
-// (tests/e2e/firefox/dapp.js), from a loopback origin rather than through a
+// (tests/e2e/dapp.js), from a loopback origin rather than through a
 // route handler. The two suites drive different browsers over different
 // protocols, but the page they drive — the __dapp API, the message log — is
 // one fixture, so an assertion written against it means the same thing on

tests/e2e/slowApproval.js

@@ -0,0 +1,530 @@
+// A transaction approval and a signature approval the user leaves open for
+// seven minutes, their windows minimized, are still answered, and the site
+// receives both results (https://git.eeqj.de/sneak/AutistMask/issues/540).
+//
+// Both approvals, and the site's requests waiting on them, live only in the
+// background worker's memory. With nothing else going on, Chrome stopped that
+// worker about six minutes after the site's request, while the window was
+// still open, and the user's answer then reached nobody. While an approval is
+// pending, the worker now makes an extension call every 20 seconds, which
+// keeps it running (addPendingApproval() in src/background/index.js). The
+// windows are minimized for the wait because
+// Chrome slows a hidden page's timers to once a minute after a few minutes,
+// so anything the window itself did to keep the worker running would fail
+// here.
+//
+// A separate program from run.js, and not driven by Playwright: Playwright
+// keeps DevTools attached to the background worker, and Chrome never stops a
+// worker DevTools is attached to, so in run.js the worker outlives any wait
+// and a wait there proves nothing. This program starts Chromium itself and
+// speaks the DevTools protocol over the pipe Chromium opens for it
+// (--remote-debugging-pipe), attaching to pages only, never to the worker.
+// Before the approvals are raised it watches the worker stop on its own, so a
+// run in which something else keeps the worker running cannot pass.
+//
+// The dApp page and the stub node are the loopback ones the Firefox suite also
+// uses (tests/e2e/dapp.js). The site is connected and the node chosen
+// through the extension's own screens, so nothing is written to its storage
+// from outside.
+//
+// Run through script/test-e2e, which builds the extension and the pinned
+// container.
+//
+//   node tests/e2e/slowApproval.js
+
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const { chromium } = require("playwright-core");
+const {
+    Transaction,
+    getAddress,
+    getBytes,
+    hexlify,
+    parseEther,
+    toQuantity,
+    toUtf8Bytes,
+    verifyMessage,
+} = require("ethers");
+
+const { PASSWORD } = require("./harness");
+const { STUB_COUNTERPARTY } = require("./network");
+const { startDappServer } = require("./dapp");
+
+const DIST_CHROME = path.resolve(__dirname, "..", "..", "dist", "chrome");
+
+// Chrome stopped the worker six minutes after the site's request when nothing
+// kept it running, so the approvals are left open for longer than that.
+const APPROVAL_WAIT_MS = 7 * 60 * 1000;
+
+// With nothing pending, Chrome stops the worker 30 seconds after its last
+// event; this is how long the program waits to see that.
+const IDLE_STOP_TIMEOUT_MS = 90000;
+
+const SIGN_HEX = hexlify(toUtf8Bytes("AutistMask e2e: a slow signature"));
+
+const checks = [];
+let failed = 0;
+
+function check(name, cond, detail) {
+    checks.push(name);
+    if (cond) {
+        console.log("ok " + checks.length + " - " + name);
+    } else {
+        failed += 1;
+        console.log("not ok " + checks.length + " - " + name);
+        if (detail) console.log("  " + detail);
+    }
+}
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Poll `probe` until it returns something truthy, and return that.
+async function until(what, probe, timeout = 30000) {
+    const deadline = Date.now() + timeout;
+    for (;;) {
+        const value = await probe().catch(() => null);
+        if (value) return value;
+        if (Date.now() > deadline) {
+            throw new Error(
+                "gave up after " + timeout + "ms waiting for " + what,
+            );
+        }
+        await sleep(250);
+    }
+}
+
+// The DevTools protocol over Chromium's pipe: commands go to its fd 3, and
+// replies and events come back on its fd 4, each one JSON message ended by a
+// NUL byte. Events are not used and are dropped. Returns send(method, params,
+// sessionId), which resolves with the command's result.
+function devtools(browser) {
+    const waiting = new Map();
+    let nextId = 1;
+    let pending = "";
+    const replies = browser.stdio[4];
+    replies.setEncoding("utf8");
+    replies.on("data", (chunk) => {
+        pending += chunk;
+        let end;
+        while ((end = pending.indexOf("\0")) !== -1) {
+            const message = JSON.parse(pending.slice(0, end));
+            pending = pending.slice(end + 1);
+            const caller = waiting.get(message.id);
+            if (!caller) continue;
+            waiting.delete(message.id);
+            if (message.error) {
+                caller.reject(
+                    new Error(caller.method + ": " + message.error.message),
+                );
+            } else {
+                caller.resolve(message.result);
+            }
+        }
+    });
+    replies.on("close", () => {
+        for (const caller of waiting.values()) {
+            caller.reject(new Error("the browser exited"));
+        }
+        waiting.clear();
+    });
+    return (method, params = {}, sessionId) =>
+        new Promise((resolve, reject) => {
+            const id = nextId++;
+            waiting.set(id, { method, resolve, reject });
+            browser.stdio[3].write(
+                JSON.stringify({ id, method, params, sessionId }) + "\0",
+            );
+        });
+}
+
+// Attach to a page and return a function that evaluates an expression in it,
+// awaiting a promise it returns, and resolves with the value.
+async function attach(send, targetId) {
+    const { sessionId } = await send("Target.attachToTarget", {
+        targetId,
+        flatten: true,
+    });
+    return async (expression) => {
+        const r = await send(
+            "Runtime.evaluate",
+            { expression, awaitPromise: true, returnByValue: true },
+            sessionId,
+        );
+        if (r.exceptionDetails) {
+            throw new Error(
+                "evaluating " +
+                    expression.slice(0, 80) +
+                    " threw: " +
+                    JSON.stringify(r.exceptionDetails.exception || {}),
+            );
+        }
+        return r.result.value;
+    };
+}
+
+// Whether the page has loaded and shows the element with this id: the
+// `hidden` class showView() keeps on every other view is on neither it nor
+// anything around it.
+function shows(id) {
+    return (
+        "document.readyState === 'complete' &&" +
+        " !!document.getElementById(" +
+        JSON.stringify(id) +
+        ") && !document.getElementById(" +
+        JSON.stringify(id) +
+        ").closest('.hidden')"
+    );
+}
+
+// Set an input's value and fire the input event typing would fire.
+function typeInto(id, value) {
+    return (
+        "(() => { const el = document.getElementById(" +
+        JSON.stringify(id) +
+        "); el.value = " +
+        JSON.stringify(value) +
+        "; el.dispatchEvent(new Event('input', { bubbles: true })); })()"
+    );
+}
+
+function click(id) {
+    return "document.getElementById(" + JSON.stringify(id) + ").click()";
+}
+
+// The outcome of a request the dApp page started with __dapp.start(), or
+// {settled: "pending"} if it has not settled within `timeout`.
+function settled(key, timeout = 30000) {
+    return (
+        "Promise.race([window.__dapp.settle(" +
+        JSON.stringify(key) +
+        "), new Promise((r) => setTimeout(() => r({ settled: 'pending' }), " +
+        timeout +
+        "))])"
+    );
+}
+
+async function main() {
+    if (!fs.existsSync(path.join(DIST_CHROME, "manifest.json"))) {
+        console.error(
+            "slowApproval: no unpacked build at " +
+                DIST_CHROME +
+                " — run make build first",
+        );
+        process.exitCode = 1;
+        return;
+    }
+
+    const node = await startDappServer();
+    const profile = fs.mkdtempSync(
+        path.join(os.tmpdir(), "autistmask-slow-approval-"),
+    );
+    const browser = spawn(
+        chromium.executablePath(),
+        [
+            "--headless",
+            // The container runs unprivileged, as in harness.js.
+            "--no-sandbox",
+            "--remote-debugging-pipe",
+            "--user-data-dir=" + profile,
+            "--disable-extensions-except=" + DIST_CHROME,
+            "--load-extension=" + DIST_CHROME,
+            // Nothing but the loopback dApp page and stub node can be reached.
+            "--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE 127.0.0.1",
+            "about:blank",
+        ],
+        { stdio: ["ignore", "ignore", "ignore", "pipe", "pipe"] },
+    );
+
+    try {
+        const send = devtools(browser);
+        const targets = async () =>
+            (await send("Target.getTargets")).targetInfos;
+
+        const worker = await until("the background worker", async () =>
+            (await targets()).find(
+                (t) =>
+                    t.type === "service_worker" &&
+                    t.url.startsWith("chrome-extension://"),
+            ),
+        );
+        // The extension id is the host of the worker's URL, as in harness.js.
+        const popupUrl =
+            "chrome-extension://" +
+            new URL(worker.url).host +
+            "/src/popup/index.html";
+        const workerRunning = async () =>
+            (await targets()).some((t) => t.url === worker.url);
+        const openPage = async (url) => {
+            const { targetId } = await send("Target.createTarget", { url });
+            return { targetId, evaluate: await attach(send, targetId) };
+        };
+        const approvalPages = async () =>
+            (await targets()).filter(
+                (t) => t.type === "page" && t.url.includes("?approval="),
+            );
+
+        // A wallet, through the popup's own screens, and the stub node as its
+        // RPC endpoint, through Settings.
+        const popup = await openPage(popupUrl);
+        await until("the welcome screen", () =>
+            popup.evaluate(shows("view-welcome")),
+        );
+        await popup.evaluate(click("btn-welcome-add"));
+        await until("the add wallet screen", () =>
+            popup.evaluate(shows("view-add-wallet")),
+        );
+        await popup.evaluate(click("btn-generate-phrase"));
+        await until("a generated recovery phrase", () =>
+            popup.evaluate(
+                "document.getElementById('wallet-mnemonic').value.trim()" +
+                    ".split(/\\s+/).length >= 12",
+            ),
+        );
+        await popup.evaluate(typeInto("add-wallet-password", PASSWORD));
+        await popup.evaluate(typeInto("add-wallet-password-confirm", PASSWORD));
+        await popup.evaluate(click("btn-add-wallet-confirm"));
+        await until(
+            "the main screen",
+            () => popup.evaluate(shows("view-main")),
+            60000,
+        );
+        await popup.evaluate(click("btn-settings"));
+        await until("the settings screen", () =>
+            popup.evaluate(shows("view-settings")),
+        );
+        await popup.evaluate(typeInto("settings-rpc", node.rpcUrl));
+        await popup.evaluate(click("btn-save-rpc"));
+        await until("the stub node saved as the RPC endpoint", () =>
+            popup.evaluate(
+                "new Promise((resolve) => chrome.storage.local.get(" +
+                    "'autistmask', (r) => resolve(r.autistmask.rpcUrl === " +
+                    JSON.stringify(node.rpcUrl) +
+                    ")))",
+            ),
+        );
+        await send("Target.closeTarget", { targetId: popup.targetId });
+
+        // The site, connected through the real prompt with "Remember", so
+        // the connection is stored rather than held by the worker.
+        const dapp = await openPage(node.url);
+        await until("the injected provider", () =>
+            dapp.evaluate("!!window.ethereum && !!window.__dapp"),
+        );
+        await dapp.evaluate(
+            "window.__dapp.start('accounts', 'eth_requestAccounts', [])",
+        );
+        const prompt = await until(
+            "the connection prompt",
+            async () => (await approvalPages())[0],
+        );
+        const inPrompt = await attach(send, prompt.targetId);
+        await until("the connection prompt's screen", () =>
+            inPrompt(shows("view-approve-site")),
+        );
+        await inPrompt(
+            "document.getElementById('approve-remember').checked = true",
+        );
+        // The prompt closes itself on the click.
+        await inPrompt(click("btn-approve")).catch(() => {});
+        const accounts = await dapp.evaluate(settled("accounts"));
+        if (accounts.settled !== "resolved") {
+            throw new Error(
+                "the site could not be connected: " + JSON.stringify(accounts),
+            );
+        }
+        const address = getAddress(accounts.result[0]);
+        console.log("# address " + address + ", site " + node.origin);
+
+        // The control: with nothing pending, the worker stops on its own.
+        // Were something else keeping it running, the wait below would
+        // prove nothing.
+        const idleStart = Date.now();
+        const stoppedWhenIdle = await until(
+            "the idle worker to stop",
+            async () => !(await workerRunning()),
+            IDLE_STOP_TIMEOUT_MS,
+        ).catch(() => false);
+        check(
+            "with nothing pending, Chrome stops the background worker on its own",
+            stoppedWhenIdle,
+            "the worker was still running " +
+                IDLE_STOP_TIMEOUT_MS / 1000 +
+                "s after its last event, so something other than the " +
+                "approval windows is keeping it running",
+        );
+        console.log(
+            "# idle worker stopped after " +
+                Math.round((Date.now() - idleStart) / 1000) +
+                "s",
+        );
+
+        // A transaction approval and a signature approval, both open at once.
+        await dapp.evaluate(
+            "window.__dapp.start('tx', 'eth_sendTransaction', [" +
+                JSON.stringify({
+                    from: address,
+                    to: STUB_COUNTERPARTY,
+                    value: toQuantity(parseEther("0.01")),
+                }) +
+                "])",
+        );
+        await until("the transaction approval window", async () =>
+            (await approvalPages()).length === 1 ? true : null,
+        );
+        await dapp.evaluate(
+            "window.__dapp.start('sign', 'personal_sign', [" +
+                JSON.stringify(SIGN_HEX) +
+                ", " +
+                JSON.stringify(address) +
+                "])",
+        );
+        const windows = await until("both approval windows", async () => {
+            const pages = await approvalPages();
+            return pages.length === 2 ? pages : null;
+        });
+        let txWindow = null;
+        let signWindow = null;
+        const windowIds = [];
+        for (const page of windows) {
+            const evaluate = await attach(send, page.targetId);
+            const view = await until("an approval screen", () =>
+                evaluate(
+                    "(" +
+                        shows("view-approve-tx") +
+                        ") ? 'tx' : (" +
+                        shows("view-approve-sign") +
+                        ") ? 'sign' : null",
+                ),
+            );
+            if (view === "tx") txWindow = evaluate;
+            if (view === "sign") signWindow = evaluate;
+            const { windowId } = await send("Browser.getWindowForTarget", {
+                targetId: page.targetId,
+            });
+            windowIds.push(windowId);
+        }
+        if (!txWindow || !signWindow) {
+            throw new Error("the two windows are not one of each kind");
+        }
+        const setWindowState = (windowState) =>
+            Promise.all(
+                windowIds.map((windowId) =>
+                    send("Browser.setWindowBounds", {
+                        windowId,
+                        bounds: { windowState },
+                    }),
+                ),
+            );
+
+        // The user minimizes both windows while deciding.
+        await setWindowState("minimized");
+        const bothHidden = await until(
+            "both approval pages hidden",
+            async () =>
+                (await txWindow("document.visibilityState")) === "hidden" &&
+                (await signWindow("document.visibilityState")) === "hidden",
+        ).catch(() => false);
+        check(
+            "both approval windows are minimized, and their pages are hidden",
+            bothHidden,
+            "a page still reports itself visible, so the wait below would " +
+                "not show what happens to a minimized approval",
+        );
+
+        // The user takes seven minutes. The worker is checked every two
+        // seconds, and the wait ends early if Chrome stops it.
+        const opened = Date.now();
+        let stoppedAfter = null;
+        while (Date.now() - opened < APPROVAL_WAIT_MS) {
+            if (!(await workerRunning())) {
+                stoppedAfter = Math.round((Date.now() - opened) / 1000);
+                break;
+            }
+            await sleep(2000);
+        }
+        check(
+            "the background worker keeps running while both approvals wait in minimized windows",
+            stoppedAfter === null,
+            "Chrome stopped the worker " +
+                stoppedAfter +
+                "s after the approvals opened",
+        );
+
+        // Back on screen to be answered.
+        await setWindowState("normal");
+        await txWindow(typeInto("approve-tx-password", PASSWORD));
+        await txWindow(click("btn-approve-tx"));
+        await signWindow(typeInto("approve-sign-password", PASSWORD));
+        // The window closes itself once the signature is handed over.
+        await signWindow(click("btn-approve-sign")).catch(() => {});
+
+        const tx = await dapp.evaluate(settled("tx"));
+        const broadcast = node.broadcast.map((raw) => Transaction.from(raw));
+        check(
+            "the transaction approved after seven minutes reaches the site",
+            tx.settled === "resolved" &&
+                broadcast.length === 1 &&
+                tx.result === broadcast[0].hash &&
+                getAddress(broadcast[0].from) === address,
+            "the page got " +
+                JSON.stringify(tx) +
+                " and the node received " +
+                broadcast.length +
+                " transaction(s)",
+        );
+
+        const sign = await dapp.evaluate(settled("sign"));
+        check(
+            "the signature approved after seven minutes reaches the site",
+            sign.settled === "resolved" &&
+                getAddress(verifyMessage(getBytes(SIGN_HEX), sign.result)) ===
+                    address,
+            "the page got " + JSON.stringify(sign),
+        );
+    } catch (e) {
+        failed += 1;
+        console.log("# ERROR: " + (e && e.stack ? e.stack : e));
+    } finally {
+        if (browser.exitCode === null && browser.signalCode === null) {
+            const exited = new Promise((resolve) =>
+                browser.once("exit", resolve),
+            );
+            browser.kill();
+            await exited;
+        }
+        await node.close();
+        // Chromium's helper processes can still be writing to the profile
+        // for a moment after the browser process itself has exited.
+        fs.rmSync(profile, { recursive: true, force: true, maxRetries: 5 });
+    }
+
+    console.log("1.." + checks.length);
+    if (checks.length === 0) {
+        console.log("# FAILED: this program asserted nothing");
+        process.exitCode = 1;
+        return;
+    }
+    console.log(
+        "# " +
+            (checks.length - failed) +
+            "/" +
+            checks.length +
+            " checks passed",
+    );
+    if (failed > 0) {
+        console.log("# FAILED");
+        process.exitCode = 1;
+    }
+}
+
+main().catch((e) => {
+    console.error("slowApproval: " + (e && e.stack ? e.stack : e));
+    process.exitCode = 1;
+});

tests/swapStatusAmount.test.js

@@ -1,342 +0,0 @@
-// The amount the wait and error screens show for a swap whose amount the
-// decoder did not read (https://git.eeqj.de/sneak/AutistMask/issues/358).
-//
-// A V4 swap action not in the deployed shape is not read, and a V4 exact-out
-// action is read for its currencies only, so the approval screen has no
-// Amount line for either. The wait and error screens then showed the
-// transaction's ETH value as the amount, in the swap's input token when the
-// calldata named one ("0.0000 WETH" for a swap of 1 WETH) and in ETH when it
-// did not ("0.0000 ETH"). They now say the amount could not be decoded. A swap
-// paid in native ETH still shows the transaction's ETH value there: that value
-// is the ETH the swap pays.
-//
-// Driven through the real approval screen, password and Confirm included,
-// against a minimal DOM stub in the shape tests/approvalNonce.test.js uses.
-// The vault is mocked so that no password has to be hashed.
-
-jest.mock("../src/shared/vault", () => ({
-    decryptWithPassword: jest.fn(),
-}));
-
-// The wait screen polls for a receipt, which is there once mockReceipt is set.
-let mockReceipt = null;
-jest.mock("../src/shared/balances", () => ({
-    getProvider: () => ({ getTransactionReceipt: async () => mockReceipt }),
-    refreshBalances: () => {},
-}));
-
-globalThis.chrome = {
-    storage: { local: { get: async () => ({}), set: async () => {} } },
-};
-
-const { AbiCoder, Interface } = require("ethers");
-const { state } = require("../src/shared/state");
-const { decryptWithPassword } = require("../src/shared/vault");
-const approval = require("../src/popup/views/approval");
-const txStatus = require("../src/popup/views/txStatus");
-
-// A well-known test phrase, and its first address.
-const PHRASE = "test test test test test test test test test test test junk";
-const FROM = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
-const TX_HASH = "0x" + "4".repeat(64);
-
-const ROUTER = "0x66a9893cc07d91d95644aedd05d03f95e1dba8af";
-const ZERO = "0x0000000000000000000000000000000000000000";
-// Both in the bundled list: WETH at 18 decimals, USDC at 6.
-const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
-const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
-const ONE_WETH = 1000000000000000000n;
-
-const coder = AbiCoder.defaultAbiCoder();
-const routerIface = new Interface([
-    "function execute(bytes commands, bytes[] inputs, uint256 deadline)",
-]);
-
-// V4 action ids and their parameters, each swapping WETH for USDC.
-const POOL_KEY = "tuple(address,address,uint24,int24,address)";
-const WETH_USDC_POOL = [WETH, USDC, 100, 1, ZERO];
-const SWAP_EXACT_IN_SINGLE = 0x06;
-const SWAP_EXACT_OUT_SINGLE = 0x08;
-const SETTLE = 0x0b;
-const SETTLE_ALL = 0x0c;
-const TAKE = 0x0e;
-const TAKE_ALL = 0x0f;
-
-// The struct V4Router has deployed on mainnet and Sepolia.
-const exactInSingle = coder.encode(
-    [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
-    [[WETH_USDC_POOL, true, ONE_WETH, 990000n, "0x"]],
-);
-// The one v4-periphery `main` has moved to, with a `minHopPriceX36` field.
-const newerExactInSingle = coder.encode(
-    [`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
-    [[WETH_USDC_POOL, true, ONE_WETH, 990000n, 0n, "0x"]],
-);
-// Deployed shape: buys 990000 base units of USDC for at most 1 WETH.
-const exactOutSingle = coder.encode(
-    [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
-    [[WETH_USDC_POOL, true, 990000n, ONE_WETH, "0x"]],
-);
-const settleWeth = coder.encode(
-    ["address", "uint256", "bool"],
-    [WETH, 0n, true],
-);
-const takeUsdc = coder.encode(
-    ["address", "address", "uint256"],
-    [USDC, FROM, 0n],
-);
-const settleAllWeth = coder.encode(["address", "uint256"], [WETH, ONE_WETH]);
-const takeAllUsdc = coder.encode(["address", "uint256"], [USDC, 990000n]);
-
-// The same swaps paid in native ETH, which V4 names as the zero address.
-const ETH_USDC_POOL = [ZERO, USDC, 500, 10, ZERO];
-const ONE_ETH = 1000000000000000000n;
-const ethExactOutSingle = coder.encode(
-    [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
-    [[ETH_USDC_POOL, true, 990000n, ONE_ETH, "0x"]],
-);
-const newerEthExactInSingle = coder.encode(
-    [`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
-    [[ETH_USDC_POOL, true, ONE_ETH, 990000n, 0n, "0x"]],
-);
-// The router pays it from the ETH the transaction sends.
-const settleEth = coder.encode(
-    ["address", "uint256", "bool"],
-    [ZERO, 0n, false],
-);
-
-// execute() with one V4_SWAP step of these actions, given as [id, params].
-function v4SwapData(actions) {
-    const input = coder.encode(
-        ["bytes", "bytes[]"],
-        [new Uint8Array(actions.map((a) => a[0])), actions.map((a) => a[1])],
-    );
-    return routerIface.encodeFunctionData("execute", [
-        "0x10",
-        [input],
-        9999999999n,
-    ]);
-}
-
-function makeElement(id) {
-    const classes = new Set();
-    const el = {
-        id,
-        textContent: "",
-        value: "",
-        innerHTML: "",
-        disabled: false,
-        style: {},
-        dataset: {},
-        listeners: {},
-        classList: {
-            add: (...names) => names.forEach((n) => classes.add(n)),
-            remove: (...names) => names.forEach((n) => classes.delete(n)),
-            contains: (n) => classes.has(n),
-            toggle: (n, force) => {
-                const on = force === undefined ? !classes.has(n) : force;
-                if (on) classes.add(n);
-                else classes.delete(n);
-                return on;
-            },
-        },
-        addEventListener: (name, fn) => {
-            el.listeners[name] = el.listeners[name] || [];
-            el.listeners[name].push(fn);
-        },
-        querySelectorAll: () => [],
-        appendChild: () => {},
-    };
-    // Views reach for .parentElement to hide whole sections.
-    Object.defineProperty(el, "parentElement", {
-        get: () => node(id + "-parent"),
-    });
-    return el;
-}
-
-function makeDocument() {
-    const els = new Map();
-    return {
-        getElementById(id) {
-            // The debug banner is created on demand by helpers.js; absent
-            // is the state a non-debug, non-testnet popup is in.
-            if (id === "debug-banner") return null;
-            if (!els.has(id)) els.set(id, makeElement(id));
-            return els.get(id);
-        },
-        createElement: () => makeElement("created"),
-        body: { prepend: () => {} },
-    };
-}
-
-function node(id) {
-    return globalThis.document.getElementById(id);
-}
-
-function click(id) {
-    return Promise.all((node(id).listeners.click || []).map((fn) => fn()));
-}
-
-// Open the approval screen for this calldata, sent to the router with `value`
-// wei (no ETH unless given), and confirm it. The background answers the signed
-// transaction with `response`.
-async function approveSwap(data, response, value = 0n) {
-    globalThis.document = makeDocument();
-    globalThis.window = { location: { search: "" }, close: () => {} };
-    globalThis.chrome.runtime = {
-        connect: () => ({ postMessage: () => {} }),
-        sendMessage: (msg, reply) => {
-            if (!reply) return;
-            if (msg.type !== "AUTISTMASK_GET_APPROVAL") return reply(response);
-            reply({
-                type: "tx",
-                origin: "https://dapp.example",
-                isPhishingDomain: false,
-                approvedFrom: FROM,
-                approvedTx: {
-                    type: 2,
-                    from: FROM,
-                    chainId: "0x1",
-                    nonce: "0x7",
-                    gasLimit: "0x30d40",
-                    maxPriorityFeePerGas: "0x3b9aca00",
-                    maxFeePerGas: "0x77359400",
-                    to: ROUTER,
-                    value: "0x" + value.toString(16),
-                    data,
-                    accessList: [],
-                },
-            });
-        },
-    };
-    state.activeAddress = FROM;
-    state.trackedTokens = [];
-    state.wallets = [
-        {
-            type: "hd",
-            name: "Wallet 1",
-            xpub: "xpub-wallet-1",
-            encryptedSecret: "encrypted-secret-1",
-            nextIndex: 1,
-            addresses: [
-                { address: FROM, index: 0, balance: "0", tokenBalances: [] },
-            ],
-        },
-    ];
-    txStatus.init({ doRefreshAndRender: () => {} });
-    approval.init({});
-    await approval.show(1);
-    decryptWithPassword.mockResolvedValue(PHRASE);
-    node("approve-tx-password").value = "any password";
-    await click("btn-approve-tx");
-}
-
-afterEach(() => {
-    txStatus.endWait();
-    mockReceipt = null;
-});
-
-describe.each([
-    [
-        "a swap action in the deployed shape",
-        [
-            [SWAP_EXACT_IN_SINGLE, exactInSingle],
-            [SETTLE, settleWeth],
-            [TAKE, takeUsdc],
-        ],
-        "1.0000 WETH",
-    ],
-    [
-        "a swap action in the newer shape, with SETTLE naming WETH",
-        [
-            [SWAP_EXACT_IN_SINGLE, newerExactInSingle],
-            [SETTLE, settleWeth],
-            [TAKE, takeUsdc],
-        ],
-        "Unknown (could not be decoded)",
-    ],
-    [
-        "a swap action in the newer shape, with SETTLE_ALL and TAKE_ALL",
-        [
-            [SWAP_EXACT_IN_SINGLE, newerExactInSingle],
-            [SETTLE_ALL, settleAllWeth],
-            [TAKE_ALL, takeAllUsdc],
-        ],
-        "Unknown (could not be decoded)",
-    ],
-    [
-        "an exact-out swap action, which is read for its currencies only",
-        [
-            [SWAP_EXACT_OUT_SINGLE, exactOutSingle],
-            [SETTLE, settleWeth],
-            [TAKE, takeUsdc],
-        ],
-        "Unknown (could not be decoded)",
-    ],
-])("%s", (_name, actions, expected) => {
-    test("the wait screen's amount", async () => {
-        await approveSwap(v4SwapData(actions), { txHash: TX_HASH });
-        expect(node("wait-tx-summary").textContent).toBe(expected);
-    });
-
-    test("the error screen's amount", async () => {
-        await approveSwap(v4SwapData(actions), {
-            error: "The transaction could not be sent.",
-            retryable: false,
-        });
-        expect(node("error-tx-summary").textContent).toBe(expected);
-    });
-
-    // The success screen shows the approval screen's decoded lines in place
-    // of the amount, so the ETH value is not on it either.
-    test("the success screen has no amount line of its own", async () => {
-        await approveSwap(v4SwapData(actions), { txHash: TX_HASH });
-        mockReceipt = { blockNumber: 1 };
-        // A later popup resumes the wait, and the receipt is there.
-        txStatus.restoreWait();
-        for (let i = 0; i < 10; i++) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-        const summary = node("success-tx-summary").parentElement;
-        expect(summary.classList.contains("hidden")).toBe(true);
-        expect(node("success-tx-decoded").innerHTML).not.toContain("0.0000");
-    });
-});
-
-// A swap paid in native ETH has a Token In of "ETH (native)" and no Amount
-// line, and sends 1 ETH.
-describe.each([
-    [
-        "an exact-out swap action paid in ETH, in the deployed shape",
-        [
-            [SWAP_EXACT_OUT_SINGLE, ethExactOutSingle],
-            [SETTLE, settleEth],
-            [TAKE, takeUsdc],
-        ],
-    ],
-    [
-        "a swap action in the newer shape paid in ETH, with SETTLE naming ETH",
-        [
-            [SWAP_EXACT_IN_SINGLE, newerEthExactInSingle],
-            [SETTLE, settleEth],
-            [TAKE, takeUsdc],
-        ],
-    ],
-])("%s", (_name, actions) => {
-    test("the wait screen shows the ETH the transaction sends", async () => {
-        await approveSwap(v4SwapData(actions), { txHash: TX_HASH }, ONE_ETH);
-        expect(node("wait-tx-summary").textContent).toBe("1.0000 ETH");
-    });
-
-    test("the error screen shows the ETH the transaction sends", async () => {
-        await approveSwap(
-            v4SwapData(actions),
-            {
-                error: "The transaction could not be sent.",
-                retryable: false,
-            },
-            ONE_ETH,
-        );
-        expect(node("error-tx-summary").textContent).toBe("1.0000 ETH");
-    });
-});

tests/uniswap.test.js

@@ -163,122 +163,6 @@ function encodeV4ExactInSingle(currency0, currency1, amountIn, amountOutMin) {
     );
 }
 
-// Each V4 swap action's parameters in two shapes: the struct V4Router has
-// deployed on mainnet and Sepolia, and the one v4-periphery `main` has since
-// moved to, which adds a `minHopPriceX36` field. Each swaps WETH for USDC.
-const POOL_KEY = "tuple(address,address,uint24,int24,address)";
-const PATH_KEY = "tuple(address,uint24,int24,address,bytes)";
-const WETH_USDC_POOL = [WETH_ADDR, USDC_ADDR, 100, 1, ZERO_ADDR];
-const ONE_WETH = 1000000000000000000n;
-const V4_SWAP_ACTION_SHAPES = [
-    {
-        action: "SWAP_EXACT_IN_SINGLE",
-        id: 0x06,
-        deployed: coder.encode(
-            [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
-            [[WETH_USDC_POOL, true, ONE_WETH, 990000n, "0x"]],
-        ),
-        newer: coder.encode(
-            [`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
-            [[WETH_USDC_POOL, true, ONE_WETH, 990000n, 0n, "0x"]],
-        ),
-    },
-    {
-        action: "SWAP_EXACT_IN",
-        id: 0x07,
-        deployed: coder.encode(
-            [`tuple(address,${PATH_KEY}[],uint128,uint128)`],
-            [
-                [
-                    WETH_ADDR,
-                    [[USDC_ADDR, 100, 1, ZERO_ADDR, "0x"]],
-                    ONE_WETH,
-                    990000n,
-                ],
-            ],
-        ),
-        newer: coder.encode(
-            [`tuple(address,${PATH_KEY}[],uint256[],uint128,uint128)`],
-            [
-                [
-                    WETH_ADDR,
-                    [[USDC_ADDR, 100, 1, ZERO_ADDR, "0x"]],
-                    [],
-                    ONE_WETH,
-                    990000n,
-                ],
-            ],
-        ),
-    },
-    {
-        action: "SWAP_EXACT_OUT_SINGLE",
-        id: 0x08,
-        deployed: coder.encode(
-            [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
-            [[WETH_USDC_POOL, true, 990000n, ONE_WETH, "0x"]],
-        ),
-        newer: coder.encode(
-            [`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
-            [[WETH_USDC_POOL, true, 990000n, ONE_WETH, 0n, "0x"]],
-        ),
-    },
-    {
-        action: "SWAP_EXACT_OUT",
-        id: 0x09,
-        deployed: coder.encode(
-            [`tuple(address,${PATH_KEY}[],uint128,uint128)`],
-            [
-                [
-                    USDC_ADDR,
-                    [[WETH_ADDR, 100, 1, ZERO_ADDR, "0x"]],
-                    990000n,
-                    ONE_WETH,
-                ],
-            ],
-        ),
-        newer: coder.encode(
-            [`tuple(address,${PATH_KEY}[],uint256[],uint128,uint128)`],
-            [
-                [
-                    USDC_ADDR,
-                    [[WETH_ADDR, 100, 1, ZERO_ADDR, "0x"]],
-                    [],
-                    990000n,
-                    ONE_WETH,
-                ],
-            ],
-        ),
-    },
-];
-
-// Helper: execute() with one V4_SWAP step holding the swap action, then
-// SETTLE of WETH and TAKE of USDC.
-function v4SwapCalldata(actionId, swapParams) {
-    return buildExecute(
-        "0x10",
-        [
-            encodeV4Swap(new Uint8Array([actionId, V4_SETTLE_ID, V4_TAKE_ID]), [
-                swapParams,
-                encodeV4Settle(WETH_ADDR),
-                encodeV4Take(USDC_ADDR),
-            ]),
-        ],
-        9999999999n,
-    );
-}
-
-// V4 SETTLE_ALL (currency, maxAmount) and TAKE_ALL (currency, minAmount). The
-// decoder reads neither, so in a V4_SWAP of a swap action and these, only the
-// swap action names the currencies.
-const V4_SETTLE_ALL_ID = 0x0c;
-const V4_TAKE_ALL_ID = 0x0f;
-function encodeV4SettleAll(currency, maxAmount) {
-    return coder.encode(["address", "uint256"], [currency, maxAmount]);
-}
-function encodeV4TakeAll(currency, minAmount) {
-    return coder.encode(["address", "uint256"], [currency, minAmount]);
-}
-
 function detail(result, label) {
     return result.details.find((d) => d.label === label);
 }
@@ -319,157 +203,9 @@ describe("uniswap decoder", () => {
             result.details.find((d) => d.label === "Min. received").value,
         ).toBe("0.0002 ETH");
 
-        // Real mainnet calldata is in the deployed shape, so its V4 step is
-        // not said to be undecoded.
         const steps = result.details.find((d) => d.label === "Steps");
-        expect(steps.value).toBe("Permit2 Permit → V4 Swap");
-    });
-
-    test.each(V4_SWAP_ACTION_SHAPES)(
-        "a V4 $action in the deployed shape is read",
-        ({ id, deployed }) => {
-            const result = uniswap.decode(
-                v4SwapCalldata(id, deployed),
-                ROUTER_ADDR,
-            );
-            expect(detail(result, "Steps").value).toBe("V4 Swap");
-        },
-    );
-
-    // https://git.eeqj.de/sneak/AutistMask/issues/358 — before it, all four
-    // newer structs decoded as the deployed ones without an error, and the
-    // newer SWAP_EXACT_IN showed the offset of its hop-price array as Amount
-    // ("0.0000000000000004 WETH") and its amountIn as Min. received.
-    test.each(V4_SWAP_ACTION_SHAPES)(
-        "a V4 $action in the newer periphery shape is shown as not decoded",
-        ({ id, newer }) => {
-            const result = uniswap.decode(
-                v4SwapCalldata(id, newer),
-                ROUTER_ADDR,
-            );
-            expect(detail(result, "Amount")).toBeUndefined();
-            expect(detail(result, "Min. received")).toBeUndefined();
-            expect(detail(result, "Steps").value).toBe(
-                "V4 Swap (could not be decoded)",
-            );
-            // SETTLE and TAKE keep their own shape and still name both sides.
-            expect(detail(result, "Token In").address).toBe(WETH_ADDR);
-            expect(detail(result, "Token Out").address).toBe(USDC_ADDR);
-        },
-    );
-
-    // Only the unread swap action names the currencies here. The token lines
-    // must not say the calldata did not name them.
-    test.each(V4_SWAP_ACTION_SHAPES)(
-        "a V4 $action in the newer shape, then SETTLE_ALL and TAKE_ALL, says both tokens could not be decoded",
-        ({ id, newer }) => {
-            const data = buildExecute(
-                "0x10",
-                [
-                    encodeV4Swap(
-                        new Uint8Array([id, V4_SETTLE_ALL_ID, V4_TAKE_ALL_ID]),
-                        [
-                            newer,
-                            encodeV4SettleAll(WETH_ADDR, ONE_WETH),
-                            encodeV4TakeAll(USDC_ADDR, 990000n),
-                        ],
-                    ),
-                ],
-                9999999999n,
-            );
-            const result = uniswap.decode(data, ROUTER_ADDR);
-            expect(detail(result, "Steps").value).toBe(
-                "V4 Swap (could not be decoded)",
-            );
-            expect(detail(result, "Token In").value).toBe(
-                "Unknown (could not be decoded)",
-            );
-            expect(detail(result, "Token Out").value).toBe(
-                "Unknown (could not be decoded)",
-            );
-        },
-    );
-
-    // The user receives the V4 step's USDC, which only its unread swap
-    // action names. The V3 step's WETH and its Min. received figure were
-    // shown instead.
-    test.each(V4_SWAP_ACTION_SHAPES)(
-        "a V3 step, then a V4 $action in the newer shape and TAKE_ALL, does not show the V3 step's output",
-        ({ id, newer }) => {
-            const data = buildExecute(
-                solidityPacked(["uint8", "uint8"], [0x00, 0x10]),
-                [
-                    encodeV3SwapExactIn(USER_ADDR, 2000000n, ONE_WETH, [
-                        USDT_ADDR,
-                        WETH_ADDR,
-                    ]),
-                    encodeV4Swap(new Uint8Array([id, V4_TAKE_ALL_ID]), [
-                        newer,
-                        encodeV4TakeAll(USDC_ADDR, 990000n),
-                    ]),
-                ],
-                9999999999n,
-            );
-            const result = uniswap.decode(data, ROUTER_ADDR);
-            expect(result.name).toBe("Uniswap Swap");
-            expect(detail(result, "Amount").value).toBe("2.0000 USDT");
-            expect(detail(result, "Token Out").value).toBe(
-                "Unknown (could not be decoded)",
-            );
-            expect(detail(result, "Min. received")).toBeUndefined();
-        },
-    );
-
-    // The user pays the V4 step's WETH, which only its unread swap action
-    // names. The V3 step's USDC and its amount were shown instead.
-    test.each(V4_SWAP_ACTION_SHAPES)(
-        "a V4 $action in the newer shape and SETTLE_ALL, then a V3 step, does not show the V3 step's input",
-        ({ id, newer }) => {
-            const data = buildExecute(
-                solidityPacked(["uint8", "uint8"], [0x10, 0x00]),
-                [
-                    encodeV4Swap(new Uint8Array([id, V4_SETTLE_ALL_ID]), [
-                        newer,
-                        encodeV4SettleAll(WETH_ADDR, ONE_WETH),
-                    ]),
-                    encodeV3SwapExactIn(
-                        USER_ADDR,
-                        990000n,
-                        980000000000000000n,
-                        [USDC_ADDR, DAI_ADDR],
-                    ),
-                ],
-                9999999999n,
-            );
-            const result = uniswap.decode(data, ROUTER_ADDR);
-            expect(result.name).toBe("Uniswap Swap");
-            expect(detail(result, "Token In").value).toBe(
-                "Unknown (could not be decoded)",
-            );
-            expect(detail(result, "Amount")).toBeUndefined();
-            expect(detail(result, "Min. received").value).toBe("0.9800 DAI");
-        },
-    );
-
-    // UNWRAP_WETH makes Token Out ETH when no step set the output side. An
-    // unread swap action's step did set it, to undetermined.
-    test("an UNWRAP_WETH after an unread V4 swap action does not make Token Out ETH", () => {
-        const { id, newer } = V4_SWAP_ACTION_SHAPES[0];
-        const data = buildExecute(
-            solidityPacked(["uint8", "uint8"], [0x10, 0x0c]),
-            [
-                encodeV4Swap(new Uint8Array([id, V4_TAKE_ALL_ID]), [
-                    newer,
-                    encodeV4TakeAll(USDC_ADDR, 990000n),
-                ]),
-                encodeWrapEth(USER_ADDR, 0n), // UNWRAP_WETH, same encoding
-            ],
-            9999999999n,
-        );
-        const result = uniswap.decode(data, ROUTER_ADDR);
-        expect(detail(result, "Token Out").value).toBe(
-            "Unknown (could not be decoded)",
-        );
+        expect(steps.value).toContain("Permit2 Permit");
+        expect(steps.value).toContain("V4 Swap");
     });
 
     test("decodes V2_SWAP_EXACT_IN with known tokens", () => {
@@ -812,11 +548,9 @@ describe("uniswap decoder", () => {
         const result = uniswap.decode(data, ROUTER_ADDR);
         expect(result).not.toBeNull();
 
-        // The V4 swap action's parameters are empty, so that step is said to
-        // be undecoded.
         const steps = result.details.find((d) => d.label === "Steps");
         expect(steps.value).toBe(
-            "Permit2 Permit \u2192 V4 Swap (could not be decoded) \u2192 Unwrap WETH",
+            "Permit2 Permit \u2192 V4 Swap \u2192 Unwrap WETH",
         );
     });
 

tests/uniswapUndeterminedTokenIn.test.js

@@ -97,11 +97,7 @@ describe("an execute() whose input currency never decoded", () => {
         ]);
 
     test("says the input token is unknown instead of naming ETH", () => {
-        // The swap action that would name it could not be read, so the line
-        // says that rather than REFUSAL's "not named in the calldata".
-        expect(detail(data(), "Token In").value).toBe(
-            "Unknown (could not be decoded)",
-        );
+        expect(detail(data(), "Token In").value).toBe(REFUSAL);
     });
 
     test("keeps a Token In line, so the screen never omits what is paid", () => {