fix: a popup save no longer undoes a network switch the background saved during it (closes #641)

The popup's saveState() and the background's updateState() each read the
stored record, change it and write it back, each ordered only within its own
context, so a write by one could land between the other's read and write and
be lost. Both now hold the browser's lock (navigator.locks) from the read to
the write, through withLock() in src/shared/browserApi.js, and the recovery
screen's reset takes it too. A page in a Firefox private window gets locks of
its own and is not covered. The lock also orders a page's own saves, so both
per-context queues are gone. The unit tests get a small lock from a Jest setup
file.

Model: opus-5-5

README.md

@@ -1129,15 +1129,13 @@ scale is not an approximation but a different number — 1,000 units of a
 6-decimal token formatted at 18 decimals reads `0.000000001` — on the screen
 whose only job is to state what is being authorized. Both amount paths of that
 screen take this rule: the ERC-20 `transfer`/`approve` line
-(`src/popup/views/approval.js`) and the swap's `Amount`, `Min. received`,
-`Moved from the sender` and `Permit2 allowance` lines and the `Paid to` line of
-a move into the router (`src/shared/uniswap.js`). The token permission warning
-on the signature screen takes the same rule for its amounts. An unbounded
-allowance or permit needs no scale to describe and is still shown as
-`Unlimited`. A source's answer counts only if it is a whole number from 0 to 80:
-`decimals()` returns a `uint8`, but `formatUnits()` cannot format more than 80
-decimal places, so a token that reports 81 to 255 is shown as one whose scale
-nothing knows.
+(`src/popup/views/approval.js`) and the swap's `Amount` and `Min. received`
+lines (`src/shared/uniswap.js`). The token permission warning on the signature
+screen takes the same rule for its amounts. An unbounded allowance or permit
+needs no scale to describe and is still shown as `Unlimited`. A source's answer
+counts only if it is a whole number from 0 to 80: `decimals()` returns a
+`uint8`, but `formatUnits()` cannot format more than 80 decimal places, so a
+token that reports 81 to 255 is shown as one whose scale nothing knows.
 
 The rule holds only if nothing invents a scale UPSTREAM of it. Those three
 sources are read as authoritative, so a value written into one of them cannot be
@@ -1262,29 +1260,17 @@ runs (Transaction Decoding below gives what the router holds). The router
 unwraps only the WETH it holds, so WETH that step paid to the user, or to anyone
 else, stays WETH: a swap that pays the router WETH, then a swap that pays the
 user WETH, then an unwrap, shows WETH with the second swap's minimum. The
-minimum reads in ETH only when that step paid all its WETH to the router and
-every step between it and the `UNWRAP_WETH` is one the decoder read of these: a
-`PERMIT2_PERMIT`, a `BALANCE_CHECK_ERC20`, or a `SWEEP`, `TRANSFER`,
-`PAY_PORTION` or `PAY_PORTION_FULL_PRECISION` of a token other than WETH, but
-not of ETH to a WETH contract, which pays the router WETH. None of these can
-take WETH out of the router or pay anyone WETH; the decoder treats every other
-step as one that may. Otherwise the swap shows ETH with no minimum, as it does
-after a V4 step that `TAKE`s some of its WETH to the user and the rest to the
-router, or that pays the router WETH beside a payout the decoder cannot read,
-and with a WETH interface fee paid by `PAY_PORTION` before the `UNWRAP_WETH`:
-the decoder does not count how much of that step's minimum reaches the
-`UNWRAP_WETH`, nor read the `UNWRAP_WETH`'s own minimum. When an `UNWRAP_WETH`
-of that WETH pays the router, or its recipient cannot be read, the router may
-hold the ETH, and a later step may pay it out as WETH, as a `WRAP_ETH` of it to
-the user does: after any later step but those listed, the swap shows WETH with
-no minimum. Once the swap shows no minimum, or shows WETH this way, no later
-step, a later `UNWRAP_WETH` included, brings back the minimum or ETH; only a
-later step that sets the output side sets it anew. 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.
+minimum reads in ETH when that step paid all its WETH to the router. When it
+paid only part of it to the router, as a V4 step does that `TAKE`s some of its
+WETH to the user and the rest to the router, or paid the router WETH beside a
+payout the decoder cannot read, the swap shows ETH with no minimum: the decoder
+does not count how much of that step's minimum reaches the router, nor read the
+`UNWRAP_WETH`'s own minimum. A later step that sets the output side sets it
+anew. 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
@@ -2094,11 +2080,8 @@ view would leave a wallet one click from deletion.
       none, and the tokens tracked on that network, and sends `chainChanged`
       with the new chain id to every open tab. A token is tracked only on the
       network it was added on, because a contract address names a token on one
-      network only. Switching also clears every address's balances. A balance
-      refresh, by the popup or the background, stores what it fetched only if
-      the stored network is still the one it fetched on when it returns, so the
-      previous network's balances never reach the new one. Choosing the network
-      already active changes nothing and sends nothing
+      network only. Choosing the network already active changes nothing and
+      sends nothing
     - Ethereum RPC: endpoint URL input + "Save" button (validated against
       `eth_chainId` before being saved)
     - Blockscout API: endpoint URL input + "Save" button (validated against
@@ -2427,12 +2410,10 @@ view would leave a wallet one click from deletion.
       transaction"
     - Decoded action (if calldata is recognized): action name, token details,
       amounts, what each swap step spends that the `Amount` line does not give,
-      what each `PERMIT2_TRANSFER_FROM` moves and where to, what each
-      `PERMIT2_PERMIT` whose amount is not the `Amount` figure, and each
-      `PERMIT2_PERMIT_BATCH`, lets its spender take, steps, deadline, and unless
-      a swap pays only the From address, a `Paid to` line for each other address
-      it pays, or saying that a token stays in the router or who it pays is
-      unknown (see Transaction Decoding)
+      what each `PERMIT2_TRANSFER_FROM` moves and where to, steps, deadline, and
+      unless a swap pays only the From address, a `Paid to` line for each other
+      address it pays, or saying that a token stays in the router or who it pays
+      is unknown (see Transaction Decoding)
     - From: color dot + full address + etherscan link
     - Contract: color dot + full address + etherscan link, token symbol label if
       known; for a contract creation, the same sentence as on WaitTx
@@ -3221,27 +3202,24 @@ Currently supported:
   added to the total while both are quantities: a V3 exact-in of 600 USDT and a
   V2 exact-in of 400 USDT, both paid by the user, read `1000.0000 USDT`. When
   the decoder does not know a take's amount, the total is not known and there is
-  no `Amount` line. A `PERMIT2_PERMIT` names `Token In` only when its amount,
-  `Unlimited` included, stands as the `Amount` figure in place of the total,
-  which it does only in the plain shape of Uniswap's own routes: it comes before
-  the step that sets the input side, it is the only `PERMIT2_PERMIT` in the
-  transaction and there is no `PERMIT2_PERMIT_BATCH`, its spender is the router,
-  the router may not let it fail, no step before it takes its token or a token
-  the decoder does not know, and the decoder reads every step after it in full.
+  no `Amount` line. `Token In` is the token of the last `PERMIT2_PERMIT` the
+  decoder reads, when there is one. Its amount, `Unlimited` included, stands as
+  the `Amount` figure in place of the total only in the plain shape of Uniswap's
+  own routes: it is the only `PERMIT2_PERMIT`, its spender is the router, the
+  router may not let it fail, no step before it takes its token or a token the
+  decoder does not know, and the decoder reads every step after it in full.
   Permit2 then lets the router take no more of the token than that amount, so
-  the permit covers every take of it. A later permit or batch may raise what
-  Permit2 lets the router take, and so may a step the decoder does not read in
-  full: a command the decoder does not read (listed at the end of this section),
-  a step whose input it cannot read, in whole or in part, and a step it fails
-  on. Every other `PERMIT2_PERMIT`, before the step that sets the input side or
-  after it, leaves `Token In` and the `Amount` line as they read with no permit:
-  a permit of 5,000 DAI to another address and then a V3 exact-in of 600 USDT
-  read `Swap USDT → USDC` with `Amount 600.0000 USDT`, and so do that exact-in
-  and then a permit of 5,000 DAI to the router. When a permit's amount stands
-  and the step that sets the input side spends a token other than the permit's,
-  or one the decoder does not know, that step's amount gets lines of its own,
-  unless it states no amount and the user pays it none of its input token. Each
-  take the total does not count gives three lines after the `Amount` line (after
+  the permit covers every take of it. A step the decoder does not read in full
+  may raise what Permit2 lets the router take, as a `PERMIT2_PERMIT_BATCH` can:
+  a command the decoder does not read (listed at the end of this section), a
+  step whose input it cannot read, in whole or in part, and a step it fails on.
+  In any other case the line gives the total, as with no permit. When the step
+  that sets the input side spends a token other than the permit's, or one the
+  decoder does not know, its amount gets lines of its own, unless it states no
+  amount and the user pays it none of its input token, and the total has no
+  figure to start from: unless the permit's amount stands there is no `Amount`
+  line, and each take of the permit's token gets lines of its own. Each take the
+  total does not count gives three lines after the `Amount` line (after
   `Token In` when there is none): one of a token other than `Token In`; one of
   `Token In` after an amount that is not a quantity (a V4 open delta,
   `ALREADY_PAID`, which keep their wording on the `Amount` line, or no stated
@@ -3278,33 +3256,17 @@ Currently supported:
   on every router but `UniversalRouterV1`, and otherwise gives the address. A
   move into the router needs none of them, because its `Paid to` line and
   `Token moved into the router` line already give the amount, the token and
-  where it goes, and so its amount is shown once. Every `PERMIT2_PERMIT` whose
-  amount does not stand as the `Amount` figure, before the step that sets the
-  input side or after it, gives three lines, in step order, after those for each
-  `PERMIT2_TRANSFER_FROM`: `Permit2 allowance`, its amount, for example
-  `5000.0000 DAI`, or `Unlimited` for Permit2's maximum; `Allowance token`,
-  giving the token's address as the `Token In` line does; and
-  `Allowance spender`, the address it lets take the token. Only a permit whose
-  amount stands gives none: the `Amount` line gives its amount, `Token In` its
-  token, and its spender is the router. Each allowance a `PERMIT2_PERMIT_BATCH`
-  grants, one for each token it names, all for its one spender, gives the same
-  three lines, in step order with those of each `PERMIT2_PERMIT`. A
-  `PERMIT2_PERMIT` or `PERMIT2_PERMIT_BATCH` whose input the decoder cannot
-  read, such as one whose token or spender word has a nonzero top byte, may let
-  any spender take any amount of any token: it gives one `Permit2 allowance`
-  line alone, reading `Unknown (could not be decoded)`, and leaves no `Amount`
-  line, whose figure might be too low. These lines change neither the `Paid to`
-  lines nor the minimum's label: a permit or batch pays nobody. A step goes
-  unread when its recipient does not decode as an address, when it is a V3 swap
-  step whose path is shorter than one token address or has bytes after its last
-  hop, or when it is a command the decoder does not read: every command other
-  than `PERMIT2_PERMIT`, `PERMIT2_PERMIT_BATCH`, `PERMIT2_TRANSFER_FROM`,
-  `V2_SWAP_EXACT_IN`, `V2_SWAP_EXACT_OUT`, `V3_SWAP_EXACT_IN`,
-  `V3_SWAP_EXACT_OUT`, `V4_SWAP`, `SWEEP`, `TRANSFER`, `PAY_PORTION`,
-  `PAY_PORTION_FULL_PRECISION`, `ACROSS_V4_DEPOSIT_V3`, `WRAP_ETH`,
-  `UNWRAP_WETH` and `BALANCE_CHECK_ERC20` (`PERMIT2_TRANSFER_FROM_BATCH`,
-  `EXECUTE_SUB_PLAN` and the NFT commands among them), or a type its release
-  names no command for.
+  where it goes, and so its amount is shown once. These lines change neither the
+  `Paid to` lines nor the minimum's label. A step goes unread when its recipient
+  does not decode as an address, when it is a V3 swap step whose path is shorter
+  than one token address or has bytes after its last hop, or when it is a
+  command the decoder does not read: every command other than `PERMIT2_PERMIT`,
+  `PERMIT2_TRANSFER_FROM`, `V2_SWAP_EXACT_IN`, `V2_SWAP_EXACT_OUT`,
+  `V3_SWAP_EXACT_IN`, `V3_SWAP_EXACT_OUT`, `V4_SWAP`, `SWEEP`, `TRANSFER`,
+  `PAY_PORTION`, `PAY_PORTION_FULL_PRECISION`, `ACROSS_V4_DEPOSIT_V3`,
+  `WRAP_ETH`, `UNWRAP_WETH` and `BALANCE_CHECK_ERC20`
+  (`PERMIT2_TRANSFER_FROM_BATCH`, `EXECUTE_SUB_PLAN` and the NFT commands among
+  them), or a type its release names no command for.
 
 ### Non-Goals Forever
 

src/background/index.js

@@ -1379,13 +1379,6 @@ const RECENT_BALANCE_REFRESH_MS = Math.floor(BALANCE_REFRESH_PERIOD_MS / 2);
 // balances that came back — by address, onto whatever storage holds NOW.
 // Applying by address rather than writing the array back is what keeps a
 // wallet or address added, renamed or deleted during the round trip.
-//
-// Nothing is applied when the network stored NOW is not the one the refresh
-// ran on. A network switch during the round trip cleared every address's
-// balances (applyChainSwitchFields()), and the previous network's must not come
-// back over them (https://git.eeqj.de/sneak/AutistMask/issues/577).
-// lastBalanceRefresh is left as the switch set it, so the next tick refreshes
-// the new network.
 async function backgroundRefresh() {
     const s = await getState();
     const now = Date.now();
@@ -1409,7 +1402,6 @@ async function backgroundRefresh() {
     }
 
     await updateState((fresh) => {
-        if (fresh.networkId !== s.networkId) return;
         for (const wallet of fresh.wallets) {
             for (const addr of wallet.addresses || []) {
                 const got = refreshed.get(String(addr.address).toLowerCase());

src/popup/index.js

@@ -68,54 +68,23 @@ let refreshInFlight = false;
 // the recovery screen: there is no profile left to refresh.
 let refreshTimer = null;
 
-// The refresh writes into a copy of the wallets. Inside the save, under the
-// lock, its results are copied onto the address records in `state` only if the
-// network it ran on is still the active one, on this page and in the stored
-// record; the background's switch, after the user approves a site's request,
-// changes only the stored record. A switch while the refresh ran cleared every
-// address's balances (applyChainSwitchFields() in
-// src/shared/chainSwitchFields.js), and the previous network's must not come
-// back over them (https://git.eeqj.de/sneak/AutistMask/issues/577). A dropped
-// refresh is not recorded as done. Results are copied by address, so an address
-// added or removed meanwhile is left as it is.
 async function doRefreshAndRender() {
     if (refreshInFlight) return;
     refreshInFlight = true;
     try {
-        const networkId = state.networkId;
-        const wallets = structuredClone(state.wallets);
         await Promise.all([
             refreshPrices(),
             refreshBalances(
-                wallets,
+                state.wallets,
                 state.rpcUrl,
                 state.blockscoutUrl,
                 state.trackedTokens,
-                networkId,
+                state.networkId,
                 pageClosed.signal,
             ),
         ]);
-        const refreshed = new Map();
-        for (const wallet of wallets) {
-            for (const addr of wallet.addresses) {
-                refreshed.set(addr.address, addr);
-            }
-        }
-        await saveState((stored) => {
-            if (state.networkId !== networkId) return false;
-            if (stored.networkId !== networkId) return false;
-            for (const wallet of state.wallets) {
-                for (const addr of wallet.addresses) {
-                    const got = refreshed.get(addr.address);
-                    if (!got) continue;
-                    for (const key of ["balance", "ensName", "tokenBalances"]) {
-                        if (got[key] !== undefined) addr[key] = got[key];
-                    }
-                }
-            }
-            state.lastBalanceRefresh = Date.now();
-            return true;
-        });
+        state.lastBalanceRefresh = Date.now();
+        await saveState();
         renderWalletList();
     } catch (e) {
         // Every call site fires this and walks away — the boot below, the ten

src/shared/state.js

@@ -467,7 +467,11 @@ function mergeNetworkEndpoints(base, ours, theirs) {
 // (caught by tests/txStatus.test.js). A page's live picture of a field it
 // does not own goes on being whatever its last loadState() saw, same as
 // before this fix; only the persisted record is guaranteed current.
-async function saveStateOnce(beforeWrite) {
+async function saveStateOnce() {
+    // A copy, so what this save compares and writes is the page's state as it
+    // stood when the save began. A change made while it waits on storage is
+    // left for the next save, which compares against this copy.
+    const current = structuredClone(snapshotPersisted());
     const result = await storageGet("autistmask");
     // The record in storage right now is about to be merged into and written
     // back, so it is validated exactly like a load validates it. Without this,
@@ -481,12 +485,6 @@ async function saveStateOnce(beforeWrite) {
     // come from storage in its loaded (self-healed) shape. See
     // normalizePersisted() in persistedState.js.
     const fresh = normalizePersisted(result.autistmask);
-    if (beforeWrite && beforeWrite(fresh) === false) return;
-
-    // A copy, so what this save compares and writes is the page's state as it
-    // stood once the stored record was read. A change made while it waits on
-    // the write is left for the next save, which compares against this copy.
-    const current = structuredClone(snapshotPersisted());
 
     const merged = { ...fresh };
     for (const key of PERSISTED_FIELDS) {
@@ -581,15 +579,10 @@ function reportSaveFailure(err) {
 // The same lock orders this page's own saves. showView() calls saveState() on
 // every navigation without awaiting it, so two saves from one page can be
 // asked for at once; they take the lock in the order they were asked, and each
-// compares the page's state, as it stands once the stored record has been read
-// and `beforeWrite` has run, against the baseline the save before it left.
-//
-// `beforeWrite`, when given, is called inside the lock with the stored record
-// as just read, before this page's state is compared against it. It may change
-// `state`, and this save writes that change. When it returns false, nothing is
-// written; any other return lets the save go ahead.
-function saveState(beforeWrite) {
-    const turn = withLock("autistmask", () => saveStateOnce(beforeWrite));
+// compares the page's state as it stands when its turn begins against the
+// baseline the save before it left.
+function saveState() {
+    const turn = withLock("autistmask", saveStateOnce);
     // Every failed save is reported, whether or not the caller awaited this
     // one. The returned promise still rejects, so a caller that DOES await
     // keeps its own error handling.

src/shared/uniswap.js

@@ -336,8 +336,7 @@ const UNNAMED_CURRENCY = "Unknown (not named in the calldata)";
 // currencies, and those commands may name one, so saying the calldata did not
 // name it would be false. The Paid to line uses it too, when a step may pay an
 // address this decoder did not read, and so do the lines for what a step
-// takes from the sender, when this decoder does not know it, and for what a
-// permit it could not read allows.
+// takes from the sender, when this decoder does not know it.
 const UNDECODED_CURRENCY = "Unknown (could not be decoded)";
 
 // The Paid to line for each token paid to the router, the swap's output or
@@ -495,9 +494,8 @@ function amountText(raw, info) {
     };
 }
 
-// The line giving a moved token, or the token of a permit, under `label`, in
-// the shape of the Token In line, so the screens show it as they show that
-// one. ETH has no address.
+// The line giving a moved token under `label`, in the shape of the Token In
+// line, so the screens show it as they show that one. ETH has no address.
 function tokenMovedLine(label, token, sources) {
     const info = tokenInfo(token, sources);
     if (!present(info.address)) {
@@ -529,32 +527,6 @@ function decodePermit2(input) {
     }
 }
 
-// Decode PERMIT2_PERMIT_BATCH (command 0x03) input bytes into the allowances
-// it grants, one for each token it names, all for its one spender, in the
-// shape decodePermit2() returns. Each release's
-// `contracts/base/Dispatcher.sol`, at the commit linked for it above, hands
-// Permit2 the batch in this shape.
-// ABI: (((address token, uint160 amount, uint48 expiration, uint48 nonce)[],
-//        address spender, uint256 sigDeadline), bytes signature)
-function decodePermit2Batch(input) {
-    try {
-        const d = coder.decode(
-            [
-                "tuple(tuple(address,uint160,uint48,uint48)[],address,uint256)",
-                "bytes",
-            ],
-            input,
-        );
-        return d[0][0].map((details) => ({
-            token: details[0],
-            amount: details[1],
-            spender: d[0][1],
-        }));
-    } catch {
-        return null;
-    }
-}
-
 // Decode BALANCE_CHECK_ERC20 (command 0x0e) input bytes. The router passes the
 // check when `owner` holds at least `minBalance` of `token`, and reads `owner`
 // as written, without map(), on every release that has the command:
@@ -624,14 +596,12 @@ function decodeV2SwapExactOut(input) {
 // token(20) ...), or null when it is not one token followed by whole hops of
 // a fee and a token (40 hex digits, then 46 per hop). The router reads only
 // whole hops and ignores any bytes after the last one, so the last 20 bytes
-// of such a path are not the token it reads there. Both are checksummed, as
-// the ABI decoder gives every other address, so a token reads the same on
-// every line.
+// of such a path are not the token it reads there.
 function decodeV3Path(pathHex) {
     const hex = pathHex.startsWith("0x") ? pathHex.slice(2) : pathHex;
     if (hex.length < 40 || (hex.length - 40) % 46 !== 0) return null;
-    const first = getAddress("0x" + hex.slice(0, 40));
-    const last = getAddress("0x" + hex.slice(-40));
+    const first = "0x" + hex.slice(0, 40);
+    const last = "0x" + hex.slice(-40);
     return { first, last };
 }
 
@@ -1238,16 +1208,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // its input currency (see decodeV4Swap()). Only a V4 step can set the
         // input side with no amount, the one case in which this is read.
         let inputPaidByUser = false;
-        // The last PERMIT2_PERMIT this decoder read before a step set the
-        // input side, or null (see permitStands after the loop).
+        // The last PERMIT2_PERMIT this decoder read, or null (see
+        // permitStands after the loop).
         let permit = null;
-        // Every allowance a PERMIT2_PERMIT or PERMIT2_PERMIT_BATCH grants,
-        // before a step set the input side or after, in step order, as
-        // { token, amount, spender, step }. A permit or batch whose input
-        // this decoder cannot read is one with a null token, amount and
-        // spender. Each but a permit whose amount is the Amount figure gets
-        // lines of its own (see after the PERMIT2_TRANSFER_FROM lines).
-        const permits = [];
         // The index of each step this decoder did not read in full: a
         // command it does not read, a step whose input it cannot read, in
         // whole or in part, and one it fails on (see permitStands).
@@ -1258,23 +1221,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         let hasUnwrapWeth = false;
         // Set when an UNWRAP_WETH pays out, as ETH, the output side's WETH,
         // which the router holds; cleared whenever the output side is set
-        // again, or a later step may pay that ETH out as WETH (see after the
-        // loop). `unwrapIntoRouterStep` is the index of the first such
-        // UNWRAP_WETH that may have paid the ETH to the router, which then
-        // holds it: its recipient is the router or cannot be read. A later
-        // UNWRAP_WETH does not replace it. It is null when there is none, and
-        // is cleared with `outputUnwrapped` when the output side is set again.
+        // again.
         let outputUnwrapped = false;
-        let unwrapIntoRouterStep = null;
-        // The index of the step that set the output side.
-        let outputStep = -1;
-        // The index of the last step this decoder treats as one that may take
-        // WETH out of the router or pay anyone WETH: any step but one it read
-        // that is a PERMIT2_PERMIT, a BALANCE_CHECK_ERC20, or a SWEEP,
-        // TRANSFER, PAY_PORTION or PAY_PORTION_FULL_PRECISION of a token
-        // other than WETH, and not of ETH to a WETH contract, which pays the
-        // router WETH (see keepsRouterWeth in the loop). None of those can.
-        let lastWethStep = -1;
         // Where the step that set the output side paid its output: the
         // recipient of a swap step, as written, or of each TAKE, TAKE_ALL and
         // TAKE_PORTION of it in a V4 step, a TAKE_ALL as paid to the sender,
@@ -1305,9 +1253,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // when no earlier hop set it. A half the establishing hop did not
         // state stays null and the line says so, rather than being filled in
         // from a different hop. A PERMIT2_PERMIT sets no side here: after the
-        // loop, one whose amount stands as the Amount figure names Token In,
-        // and the Amount line is formed there, in one place (see
-        // permitStands).
+        // loop, the last one read names Token In, and the Amount line is
+        // formed there, in one place (see permitStands).
         const setInput = (token, amount) => {
             inputToken = present(token) ? token : null;
             inputAmount = present(amount) ? amount : null;
@@ -1318,15 +1265,13 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             if (!present(token) && !present(amount)) return;
             setInput(token, amount);
         };
-        const setOutput = (step, token, amount, recipients) => {
+        const setOutput = (token, amount, recipients) => {
             if (!present(token) && !present(amount)) return;
             outputToken = present(token) ? token : null;
             minOutput = present(amount) ? amount : null;
             outputEstablished = true;
             outputUnwrapped = false;
-            unwrapIntoRouterStep = null;
             outputRecipients = recipients;
-            outputStep = step;
         };
 
         // What the steps take from the sender beyond the amount of the step
@@ -1351,14 +1296,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         const spentUnread = () => {
             userPaid.push({ token: null, amount: null });
         };
-        // A PERMIT2_PERMIT or PERMIT2_PERMIT_BATCH at `step` whose input this
-        // decoder cannot read may let any spender take any amount of any
-        // token: one line says so, and there is no Amount line, whose figure
-        // may then be too low.
-        const permitUnread = (step) => {
-            permits.push({ token: null, amount: null, spender: null, step });
-            stepsUnread.push(step);
-        };
 
         // Who the steps pay, in whichever step and of whatever token.
         // MSG_SENDER is the sender. The router itself, as ADDRESS_THIS or by
@@ -1468,14 +1405,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     v2PairFor(chainId, next.path[0], next.path[1]).toLowerCase()
             );
         };
-        // Whether a SWEEP, TRANSFER, PAY_PORTION or PAY_PORTION_FULL_PRECISION
-        // of `token` to `recipient` pays anyone WETH (see lastWethStep): it
-        // does when `token` is WETH, and when it pays ETH to a WETH contract,
-        // which pays the router WETH for it.
-        const paysWeth = (token, recipient) =>
-            WETH_ADDRESSES.includes(token.toLowerCase()) ||
-            (token === "0x0000000000000000000000000000000000000000" &&
-                WETH_ADDRESSES.includes(recipient.toLowerCase()));
 
         for (let i = 0; i < commandsBytes.length; i++) {
             const cmdId = commandsBytes[i] & commandTypeMask;
@@ -1492,9 +1421,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     ? COMMAND_NAMES[command]
                     : "Command 0x" + cmdId.toString(16).padStart(2, "0"),
             );
-            // Set by a branch below that reads a step that cannot take WETH
-            // out of the router or pay anyone WETH (see lastWethStep).
-            let keepsRouterWeth = false;
 
             try {
                 if (command === "EXECUTE_SUB_PLAN") {
@@ -1511,42 +1437,23 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 } else if (command === "PERMIT2_PERMIT") {
                     const p = decodePermit2(inputs[i]);
                     if (p) {
-                        permits.push({ ...p, step: i });
-                        keepsRouterWeth = true;
-                    } else {
-                        permitUnread(i);
-                    }
-                    // Only a permit whose amount stands as the Amount figure
-                    // names Token In (see permitStands). Every other permit,
-                    // before the step that sets the input side or after it,
-                    // leaves Token In and Amount as they read with no permit
-                    // and gets lines of its own. One after a step set the input
-                    // side never stands, so only one before it is kept here.
-                    if (p && !inputEstablished) {
                         // Whether a step before it took its token, or may
-                        // have: one in `userPaid`, when its token is the
-                        // permit's or not known. No step has set the input
-                        // side yet.
+                        // have: the step that set the input side or one in
+                        // `userPaid`, when its token is the permit's or not
+                        // known.
                         const mayBeItsToken = (token) =>
                             !present(token) || sameAddress(token, p.token);
-                        const tookBefore = userPaid.some((t) =>
-                            mayBeItsToken(t.token),
-                        );
+                        const tookBefore =
+                            (inputEstablished && mayBeItsToken(inputToken)) ||
+                            userPaid.some((t) => mayBeItsToken(t.token));
                         permit = {
                             ...p,
                             step: i,
                             allowedToFail,
                             beforeEveryTake: !tookBefore,
                         };
-                    }
-                } else if (command === "PERMIT2_PERMIT_BATCH") {
-                    // Each allowance it grants gets the lines of a permit
-                    // whose amount does not stand. It pays nobody.
-                    const batch = decodePermit2Batch(inputs[i]);
-                    if (batch) {
-                        permits.push(...batch.map((p) => ({ ...p, step: i })));
                     } else {
-                        permitUnread(i);
+                        stepsUnread.push(i);
                     }
                 } else if (command === "PERMIT2_TRANSFER_FROM") {
                     const p = decodePermit2TransferFrom(inputs[i]);
@@ -1600,7 +1507,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         // what the user receives: it sets no side, and the
                         // step says so.
                         commandNames[i] += " (of another address)";
-                        keepsRouterWeth = true;
                     } else {
                         // The router passes this check whenever the owner
                         // holds at least minBalance, so a zero one guarantees
@@ -1611,9 +1517,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         // does. It pays nobody.
                         const minBalance = allowedToFail ? 0n : b.minBalance;
                         if (!(minBalance === 0n && present(minOutput))) {
-                            setOutput(i, b.token, minBalance, []);
+                            setOutput(b.token, minBalance, []);
                         }
-                        keepsRouterWeth = true;
                     }
                 } else if (command === "V3_SWAP_EXACT_IN") {
                     const s = decodeV3SwapExactIn(inputs[i]);
@@ -1626,7 +1531,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         // Always update output: in multi-step swaps (V3 → V4),
                         // the last swap step determines the final output token
                         // and minimum received amount.
-                        setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
+                        setOutput(s.tokenOut, s.amountOutMin, [s.recipient]);
                         if (!s.payerIsUser) {
                             spendFromRouter(s.tokenIn, s.amountIn);
                         }
@@ -1646,7 +1551,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountIn);
                         }
-                        setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
+                        setOutput(s.tokenOut, s.amountOutMin, [s.recipient]);
                         if (!s.payerIsUser) {
                             spendFromRouter(s.tokenIn, s.amountIn);
                         }
@@ -1677,7 +1582,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountInMax);
                         }
-                        setOutput(i, s.tokenOut, s.amountOut, [s.recipient]);
+                        setOutput(s.tokenOut, s.amountOut, [s.recipient]);
                         if (!isHop(i, s.tokenOut, s.recipient)) {
                             addPayee(s.recipient, s.tokenOut);
                         }
@@ -1699,7 +1604,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         if (!isRouter(s.recipient)) {
                             heldByRouter.delete(s.token.toLowerCase());
                         }
-                        keepsRouterWeth = !paysWeth(s.token, s.recipient);
                     } else {
                         payeeUnread = true;
                         stepsUnread.push(i);
@@ -1737,7 +1641,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         ) {
                             heldByRouter.delete(t.token.toLowerCase());
                         }
-                        keepsRouterWeth = !paysWeth(t.token, t.recipient);
                     } else {
                         payeeUnread = true;
                         stepsUnread.push(i);
@@ -1862,21 +1765,14 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         minOutput = v4.amountOutMin;
                         outputEstablished = true;
                         outputUnwrapped = false;
-                        unwrapIntoRouterStep = null;
                         outputRecipients = takeRecipients;
-                        outputStep = i;
                     } else if (v4) {
                         // A step with no swap action sets only the sides its
                         // SETTLE, SETTLE_ALL, TAKE or TAKE_ALL names:
                         // setInputOnce() and setOutput() leave alone a side
                         // whose two halves are both unstated.
                         setInputOnce(v4.tokenIn, amountIn);
-                        setOutput(
-                            i,
-                            v4.tokenOut,
-                            v4.amountOutMin,
-                            takeRecipients,
-                        );
+                        setOutput(v4.tokenOut, v4.amountOutMin, takeRecipients);
                     }
                     // Every V4 step, with a swap action or without, takes
                     // from the sender what the user pays it (an amount an
@@ -1903,17 +1799,12 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     // among it when the step that set the output side paid it
                     // to the router and the router still holds WETH. WETH
                     // that step paid to the user, or to anyone else, stays
-                    // WETH. When that step also paid some of its output
-                    // elsewhere or made a payout this decoder did not read,
-                    // or this decoder treats a step between the two as one
-                    // that may take WETH out of the router or pay anyone WETH
-                    // (see lastWethStep), the WETH unwrapped may be only part
-                    // of the output side's, or none of it.
-                    // This decoder does not count how much of that step's
-                    // minimum then reaches the UNWRAP_WETH, nor read the
-                    // UNWRAP_WETH's own minimum, so the output side keeps no
-                    // figure.
-                    const u = decodeUnwrapWeth(inputs[i]);
+                    // WETH, so when that step also paid some of its output
+                    // elsewhere, or made a payout this decoder did not read,
+                    // only part of it may be unwrapped. This decoder does not
+                    // count how much of that step's minimum then reaches the
+                    // router, nor read the UNWRAP_WETH's own minimum, so the
+                    // output side keeps no figure.
                     const toRouter = (r) => present(r) && isRouter(r);
                     if (
                         present(outputToken) &&
@@ -1922,19 +1813,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         outputRecipients.some(toRouter)
                     ) {
                         outputUnwrapped = true;
-                        if (
-                            unwrapIntoRouterStep === null &&
-                            (u === null || isRouter(u.recipient))
-                        ) {
-                            unwrapIntoRouterStep = i;
-                        }
-                        if (
-                            !outputRecipients.every(toRouter) ||
-                            lastWethStep > outputStep
-                        ) {
+                        if (!outputRecipients.every(toRouter)) {
                             minOutput = null;
                         }
                     }
+                    const u = decodeUnwrapWeth(inputs[i]);
                     if (u) {
                         addPayee(u.recipient);
                         // It pays out all the router's WETH, as ETH. Into the
@@ -1956,8 +1839,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     }
                 } else {
                     // Any other step may pay an address this decoder does not
-                    // read: the NFT commands among them, and a type the
-                    // release names no command for.
+                    // read: PERMIT2_PERMIT_BATCH and the NFT commands among
+                    // them, and a type the release names no command for.
                     payeeUnread = true;
                     stepsUnread.push(i);
                 }
@@ -1971,26 +1854,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             if (allowedToFail) {
                 commandNames[i] += " (allowed to fail)";
             }
-            if (!keepsRouterWeth) {
-                lastWethStep = i;
-            }
-        }
-
-        // After an UNWRAP_WETH that may have paid the output side's WETH to
-        // the router as ETH, a later step may pay that ETH out as WETH, as a
-        // WRAP_ETH of it to the user does. This decoder treats every later
-        // step but those lastWethStep names as one that may, and does not
-        // count how much of that ETH each pays out: after one, the output
-        // side reads as WETH with no figure. Neither this nor the loss of the
-        // figure in the UNWRAP_WETH branch is undone by any later step, a
-        // later UNWRAP_WETH included, but one that sets the output side again.
-        if (
-            outputUnwrapped &&
-            unwrapIntoRouterStep !== null &&
-            lastWethStep > unwrapIntoRouterStep
-        ) {
-            outputUnwrapped = false;
-            minOutput = null;
         }
 
         // The Amount line, and the lines for what the steps take beyond it.
@@ -2003,23 +1866,18 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // lines of its own. One whose amount is not known also leaves the
         // total unknown, with no figure.
         //
-        // A PERMIT2_PERMIT names Token In only when its amount stands as the
-        // Amount figure in place of the total, which it does only in the
-        // plain shape of Uniswap's own routes: it comes before the step that
-        // set the input side, it is the only PERMIT2_PERMIT in the
-        // transaction and there is no PERMIT2_PERMIT_BATCH, its spender is
+        // The last PERMIT2_PERMIT read names Token In. Its amount stands as
+        // the Amount figure in place of the total only in the plain shape of
+        // Uniswap's own routes: it is the only PERMIT2_PERMIT, its spender is
         // the router, the router may not let it fail, no step before it took
         // its token or one not known, and this decoder read every step after
         // it in full (see stepsUnread). Permit2 then lets the router take no
         // more of the token than that amount, so the permit covers every take
-        // of it. A later permit or batch, or a later step this decoder did
-        // not read, may raise what Permit2 lets the router take. Every other
-        // PERMIT2_PERMIT leaves Token In and the Amount line as they read with
-        // no permit, and gets lines of its own below. A step that may take
-        // from the sender what this decoder did not read leaves no figure,
-        // permit or not (see spentUnread()), and so does a permit or batch
-        // whose input it cannot read (see permitUnread()). An
-        // EXECUTE_SUB_PLAN step leaves both sides unknown (below).
+        // of it. A later step this decoder did not read may raise what Permit2
+        // lets the router take, as a PERMIT2_PERMIT_BATCH can. A step that
+        // may take from the sender what this decoder did not read leaves no
+        // figure, permit or not (see spentUnread()), and an EXECUTE_SUB_PLAN
+        // step leaves both sides unknown (below).
         const stepCommands = Array.from(
             commandsBytes,
             (b) => commands[b & commandTypeMask],
@@ -2027,7 +1885,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         const permitStands =
             permit !== null &&
             stepCommands.filter((c) => c === "PERMIT2_PERMIT").length === 1 &&
-            !stepCommands.includes("PERMIT2_PERMIT_BATCH") &&
             sameAddress(permit.spender, toAddress) &&
             !permit.allowedToFail &&
             permit.beforeEveryTake &&
@@ -2047,17 +1904,17 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // The take of the step that set the input side, when the total
         // starts from it and it stated no amount (see below), or null.
         let firstTakeUnstated = null;
-        if (!permitStands || sameAddress(inputToken, permit.token)) {
+        if (permit === null || sameAddress(inputToken, permit.token)) {
             total = inputAmount;
             if (hasFirstTake && !present(inputAmount)) {
                 firstTakeUnstated = { token: inputToken, amount: null };
             }
         } else if (hasFirstTake) {
             // The step that set the input side spent a token other than the
-            // permit's, or one not known, so its amount gets lines of its own.
+            // permit's, or one not known, so the total starts with no figure.
             spentFromSender.push({ token: inputToken, amount: inputAmount });
         }
-        if (permitStands) inputToken = permit.token;
+        if (permit !== null) inputToken = permit.token;
         for (const t of userPaid) {
             const ofTokenIn = sameAddress(t.token, inputToken);
             if (ofTokenIn && permitStands) continue;
@@ -2090,9 +1947,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         }
 
         // The commands of an EXECUTE_SUB_PLAN step may spend the user's tokens
-        // or pay the user, before or after any other step. What the other
-        // steps state is then not the whole swap, so both sides are set
-        // unknown, with no figure, wherever the step stands.
+        // or pay the user, before or after any other step, and a permit among
+        // them would name Token In. What the other steps state is
+        // then not the whole swap, so both sides are set unknown, with no
+        // figure, wherever the step stands.
         if (hasSubPlan) {
             inputToken = null;
             inputAmount = null;
@@ -2196,13 +2054,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         };
 
         // A null token in `spentFromSender`, a step this decoder did not read
-        // or a token it does not know, and one in `permits`, a permit or
-        // batch it could not read, leave no Amount figure, which may then be
-        // too low.
+        // or a token it does not know, leaves no Amount figure, which may
+        // then be too low.
         if (
             present(inputAmount) &&
-            spentFromSender.every((s) => present(s.token)) &&
-            permits.every((p) => present(p.token))
+            spentFromSender.every((s) => present(s.token))
         ) {
             const amount = spentText(inputAmount, inInfo);
             details.push({
@@ -2252,40 +2108,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             );
         }
 
-        // What each allowance of a PERMIT2_PERMIT or PERMIT2_PERMIT_BATCH lets
-        // its spender take: its amount, its token and the spender, an address
-        // on a line of its own. Permit2's maximum is unbounded. Only a permit
-        // whose amount stands as the Amount figure (see permitStands) gets
-        // none: that line already gives its amount and Token In its token,
-        // and its spender is the router. Every other allowance, one after the
-        // step that set the input side included, gets these lines, so nothing
-        // it lets anyone take goes unstated. A permit or batch this decoder
-        // could not read gets one line saying so.
-        for (const p of permits) {
-            if (permitStands && p.step === permit.step) continue;
-            if (!present(p.token)) {
-                details.push({
-                    label: "Permit2 allowance",
-                    value: UNDECODED_CURRENCY,
-                });
-                continue;
-            }
-            details.push({
-                label: "Permit2 allowance",
-                value:
-                    p.amount >= MAX_UINT160
-                        ? "Unlimited"
-                        : amountText(p.amount, tokenInfo(p.token, sources))
-                              .display,
-            });
-            details.push(tokenMovedLine("Allowance token", p.token, sources));
-            details.push({
-                label: "Allowance spender",
-                value: p.spender,
-                address: p.spender,
-            });
-        }
-
         // 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

tests/backgroundStateIsolation.test.js

@@ -19,10 +19,7 @@
 //     that followed persisted the pre-refresh values — while still stamping
 //     lastBalanceRefresh, suppressing the redo.
 //
-// A network switch landing inside a balance refresh's round trip is covered at
-// the end (https://git.eeqj.de/sneak/AutistMask/issues/577).
-//
-// All use the real persistence path over a cloning storage stub. Nothing here
+// Both use the real persistence path over a cloning storage stub. Nothing here
 // asserts the absence of a loadState() call; each asserts the OUTCOME, so it
 // holds against any implementation that gets the outcome right.
 
@@ -398,48 +395,3 @@ describe("a balance refresh under another handler's state read", () => {
         expect(after.wallets[0].addresses[0].balance).toBe(REFRESHED_BALANCE);
     });
 });
-
-describe("a balance refresh under a network switch", () => {
-    // https://git.eeqj.de/sneak/AutistMask/issues/577. The switch clears every
-    // address's balances, and a refresh that started on the previous network
-    // must not write that network's back over them when it returns. The same
-    // refresh in the popup is in tests/balanceRefreshNetworkSwitch.test.js.
-    test("a refresh that returns after a switch writes nothing, and the next one runs on the new network", async () => {
-        const roundTrip = deferred();
-        const reachedNetwork = deferred();
-        const ranOn = [];
-
-        const bg = loadWorker("sepolia", {
-            refreshBalances: async (wallets, rpcUrl, explorer, tokens, id) => {
-                ranOn.push(id);
-                reachedNetwork.resolve();
-                await roundTrip.promise;
-                wallets[0].addresses[0].balance = REFRESHED_BALANCE;
-            },
-        });
-
-        const refresh = bg.fireBalanceAlarm();
-        await reachedNetwork.promise;
-
-        // The user switches to Ethereum Mainnet in Settings while the round
-        // trip is out.
-        const during = bg.persisted();
-        applyChainSwitchFields(during, MAINNET.id);
-        global.chrome.storage.write("autistmask", during);
-
-        roundTrip.resolve();
-        await refresh;
-
-        const after = bg.persisted();
-        expect(after.networkId).toBe("mainnet");
-        expect(after.wallets[0].addresses[0].balance).toBe("0");
-        expect(after.lastBalanceRefresh).toBe(0);
-
-        await bg.fireBalanceAlarm();
-
-        expect(ranOn).toEqual(["sepolia", "mainnet"]);
-        expect(bg.persisted().wallets[0].addresses[0].balance).toBe(
-            REFRESHED_BALANCE,
-        );
-    });
-});

tests/balanceRefreshNetworkSwitch.test.js

@@ -1,160 +0,0 @@
-// A balance refresh the popup started on one network, and that returns after
-// the network was switched to another, writes nothing: the switch cleared every
-// address's balances, and the previous network's must not come back over them
-// (https://git.eeqj.de/sneak/AutistMask/issues/577). The switch is made either
-// by the user in this popup's Settings, or by the background after the user
-// approved a site's request, which changes only the stored record. Driven
-// through the real popup over a stored profile on Ethereum Mainnet. The same
-// refresh in the background is in tests/backgroundStateIsolation.test.js.
-
-const {
-    bootPopup,
-    cleanupPopup,
-    unversionedValidProfile,
-    TOKEN_ADDRESS,
-} = require("./support/popupBoot");
-const { applyChainSwitchFields } = require("../src/shared/chainSwitchFields");
-
-afterEach(() => {
-    cleanupPopup();
-});
-
-// Starts the ten-second refresh and holds it open. The balance stand-in writes
-// Ethereum Mainnet's balances in place, on the records handed in, as the real
-// refreshBalances() does, once the returned function is called. Resolves with
-// that function and the refresh still running.
-async function holdRefresh(page) {
-    const { refreshBalances } = require("../src/shared/balances");
-    let answer;
-    refreshBalances.mockImplementationOnce(async (wallets) => {
-        await new Promise((resolve) => {
-            answer = resolve;
-        });
-        wallets[0].addresses[0].balance = "7.0";
-        wallets[0].addresses[0].tokenBalances = [
-            {
-                address: TOKEN_ADDRESS,
-                name: "Test Token",
-                symbol: "TST",
-                decimals: 18,
-                balance: "5.0",
-                holders: null,
-            },
-        ];
-    });
-    const ticking = page.tick();
-    await page.settle();
-    return {
-        finish: async () => {
-            answer();
-            await ticking;
-        },
-    };
-}
-
-// Picks `networkId` in the Settings network selector, as the user does.
-async function chooseNetwork(page, networkId) {
-    const select = page.node("settings-network");
-    select.value = networkId;
-    for (const fn of select.listeners.change) await fn();
-    await page.settle();
-}
-
-// The stored record holds none of Ethereum Mainnet's balances, and no refresh
-// recorded as done.
-function expectNothingStored(page) {
-    const stored = page.storage.read("autistmask");
-    expect(stored.networkId).toBe("sepolia");
-    expect(stored.wallets[0].addresses[0].balance).toBe("0");
-    expect(stored.wallets[0].addresses[0].tokenBalances).toEqual([]);
-    expect(stored.lastBalanceRefresh).toBe(0);
-}
-
-test("a refresh that returns after a switch in Settings writes nothing, and the next one runs on the new network", async () => {
-    const page = await bootPopup(unversionedValidProfile());
-    expect(page.pageErrors).toEqual([]);
-    const { refreshBalances } = require("../src/shared/balances");
-    const { state } = require("../src/shared/state");
-
-    const refresh = await holdRefresh(page);
-    await page.click("btn-settings");
-    await chooseNetwork(page, "sepolia");
-    await refresh.finish();
-
-    expect(state.wallets[0].addresses[0].balance).toBe("0");
-    expect(state.wallets[0].addresses[0].tokenBalances).toEqual([]);
-    expectNothingStored(page);
-
-    await page.click("btn-settings-back");
-    expect(page.visibleViews()).toEqual(["main"]);
-    expect(page.text("total-value")).toBe("0.0000 SepoliaETH");
-
-    await page.tick();
-
-    expect(refreshBalances.mock.lastCall[4]).toBe("sepolia");
-    expect(page.storage.read("autistmask").lastBalanceRefresh).toBeGreaterThan(
-        0,
-    );
-});
-
-// The stored record still holds Ethereum Mainnet while the refresh's save reads
-// it, so only this page's own network shows the switch.
-test("a refresh whose save is reading the stored record when the user switches in Settings writes nothing", async () => {
-    const page = await bootPopup(unversionedValidProfile());
-    expect(page.pageErrors).toEqual([]);
-    const { state } = require("../src/shared/state");
-
-    const refresh = await holdRefresh(page);
-    await page.click("btn-settings");
-
-    // The next read of the stored record, the refresh's save's, is held.
-    const get = page.storage.local.get;
-    const read = get.getMockImplementation();
-    let releaseRead;
-    get.mockImplementationOnce(async (key) => {
-        await new Promise((resolve) => {
-            releaseRead = resolve;
-        });
-        return read(key);
-    });
-    const finishing = refresh.finish();
-    await page.settle();
-
-    // The user picks Sepolia meanwhile; the switch's own save waits for the
-    // refresh's save to let the lock go.
-    const select = page.node("settings-network");
-    select.value = "sepolia";
-    const switching = Promise.all(select.listeners.change.map((fn) => fn()));
-    await page.settle();
-
-    releaseRead();
-    await finishing;
-    await switching;
-    await page.settle();
-
-    expect(state.networkId).toBe("sepolia");
-    expect(state.wallets[0].addresses[0].balance).toBe("0");
-    expect(state.wallets[0].addresses[0].tokenBalances).toEqual([]);
-    expectNothingStored(page);
-});
-
-test("a refresh that returns after the background switched the network writes nothing", async () => {
-    const page = await bootPopup(unversionedValidProfile());
-    expect(page.pageErrors).toEqual([]);
-    const { saveState } = require("../src/shared/state");
-
-    const refresh = await holdRefresh(page);
-    // The background writes the switch to Sepolia, as its updateState() does
-    // once the user approves a site's request. This page is not told.
-    const record = page.storage.read("autistmask");
-    applyChainSwitchFields(record, "sepolia");
-    page.storage.write("autistmask", record);
-    await refresh.finish();
-
-    expectNothingStored(page);
-
-    // Nor does a later save by this page, such as every navigation makes.
-    await saveState();
-
-    expectNothingStored(page);
-});

tests/uniswap.test.js

@@ -1,4 +1,4 @@
-const { AbiCoder, Interface, getAddress, solidityPacked } = require("ethers");
+const { AbiCoder, Interface, solidityPacked } = require("ethers");
 const uniswap = require("../src/shared/uniswap");
 
 // A Universal Router on Ethereum Mainnet, chain id 0x1: UniversalRouterV2,
@@ -59,25 +59,6 @@ function encodePermit2(token, amount, spender) {
     );
 }
 
-// Helper: encode a PERMIT2_PERMIT_BATCH input (command 0x03), one allowance
-// for each [token, amount], all for `spender`
-function encodePermit2Batch(allowances, spender) {
-    return coder.encode(
-        [
-            "tuple(tuple(address,uint160,uint48,uint48)[],address,uint256)",
-            "bytes",
-        ],
-        [
-            [
-                allowances.map(([token, amount]) => [token, amount, 0, 0]),
-                spender,
-                9999999999,
-            ],
-            "0x1234",
-        ],
-    );
-}
-
 // Helper: encode a BALANCE_CHECK_ERC20 input (command 0x0e)
 function encodeBalanceCheck(owner, token, minBalance) {
     return coder.encode(
@@ -715,8 +696,12 @@ describe("uniswap decoder", () => {
                 USER_ADDR,
             );
             expect(result.name).toBe("Swap USDT → WETH");
-            expect(detail(result, "Token In").address).toBe(USDT_ADDR);
-            expect(detail(result, "Token Out").address).toBe(WETH_ADDR);
+            expect(detail(result, "Token In").address).toBe(
+                USDT_ADDR.toLowerCase(),
+            );
+            expect(detail(result, "Token Out").address).toBe(
+                WETH_ADDR.toLowerCase(),
+            );
 
             const amount = detail(result, "Amount");
             expect(amount.value).toBe("Up to 2000.0000 USDT");
@@ -750,7 +735,9 @@ describe("uniswap decoder", () => {
         expect(result.name).toBe("Swap ETH → USDC");
         expect(detail(result, "Amount").value).toBe("Up to 0.5000 ETH");
         expect(detail(result, "Moved from the sender")).toBeUndefined();
-        expect(detail(result, "Token Out").address).toBe(USDC_ADDR);
+        expect(detail(result, "Token Out").address).toBe(
+            USDC_ADDR.toLowerCase(),
+        );
         expect(detail(result, "Paid to")).toBeUndefined();
         expect(detail(result, "Min. received").value).toBe("1500.0000 USDC");
     });
@@ -1419,14 +1406,6 @@ describe("uniswap decoder", () => {
             return lines.slice(from + 1, to);
         }
 
-        // The lines of a PERMIT2_PERMIT whose amount does not stand as the
-        // Amount figure, of `amount` of `token` for `spender`.
-        const permitLines = (amount, token, symbol, spender) => [
-            ["Permit2 allowance", amount],
-            ["Allowance token", symbol + " (" + token + ")"],
-            ["Allowance spender", getAddress(spender)],
-        ];
-
         // execute() of these command bytes and inputs, decoded as sent by
         // the user.
         function decodeSteps(commands, inputs) {
@@ -1732,7 +1711,6 @@ describe("uniswap decoder", () => {
                 kind: "a V4 step swapping 400 USDT with a SETTLE of 5,000 USDT by the user, the rest taken to another address,",
                 commands: [0x10],
                 inputs: [V4_SETTLE_5000],
-                permit: [],
             },
             {
                 kind: "a PERMIT2_PERMIT of 1 USDT that the router may let fail, then that V4 step,",
@@ -1741,12 +1719,6 @@ describe("uniswap decoder", () => {
                     encodePermit2(USDT_ADDR, 1000000n, ROUTER_ADDR),
                     V4_SETTLE_5000,
                 ],
-                permit: permitLines(
-                    "1.0000 USDT",
-                    USDT_ADDR,
-                    "USDT",
-                    ROUTER_ADDR,
-                ),
             },
             // The unread SWEEP keeps the permit's amount from standing.
             {
@@ -1763,18 +1735,11 @@ describe("uniswap decoder", () => {
                         1,
                     ),
                 ],
-                permit: permitLines(
-                    "5000.0000 USDT",
-                    USDT_ADDR,
-                    "USDT",
-                    ROUTER_ADDR,
-                ),
             },
-        ])("$kind shows the 5,000 USDT", ({ commands, inputs, permit }) => {
+        ])("$kind shows the 5,000 USDT", ({ commands, inputs }) => {
             const result = decodeSteps(commands, inputs);
             expect(linesBetweenTokens(result)).toEqual([
                 ["Amount", "5000.0000 USDT"],
-                ...permit,
             ]);
         });
 
@@ -2058,24 +2023,19 @@ describe("uniswap decoder", () => {
         });
 
         // Out of that shape the permit caps nothing the Amount line can rely
-        // on, so the line gives the total the steps take, as with no permit,
-        // and each permit gets lines of its own.
+        // on, so the line gives the total the steps take, as with no permit.
         const ONE_USDT_PERMIT = (spender) =>
             encodePermit2(USDT_ADDR, 1000000n, spender);
-        const ONE_USDT_LINES = (spender) =>
-            permitLines("1.0000 USDT", USDT_ADDR, "USDT", spender);
         test.each([
             {
                 kind: "to another spender",
                 commands: [0x0a],
                 permits: [ONE_USDT_PERMIT(OTHER_ADDR)],
-                lines: ONE_USDT_LINES(OTHER_ADDR),
             },
             {
                 kind: "that the router lets fail",
                 commands: [0x8a],
                 permits: [ONE_USDT_PERMIT(ROUTER_ADDR)],
-                lines: ONE_USDT_LINES(ROUTER_ADDR),
             },
             {
                 kind: "followed by a second one",
@@ -2084,14 +2044,10 @@ describe("uniswap decoder", () => {
                     ONE_USDT_PERMIT(ROUTER_ADDR),
                     ONE_USDT_PERMIT(ROUTER_ADDR),
                 ],
-                lines: [
-                    ...ONE_USDT_LINES(ROUTER_ADDR),
-                    ...ONE_USDT_LINES(ROUTER_ADDR),
-                ],
             },
         ])(
             "a split after a PERMIT2_PERMIT $kind shows the total the steps take",
-            ({ commands, permits, lines }) => {
+            ({ commands, permits }) => {
                 const result = decodeSteps(
                     [...commands, 0x00, 0x08],
                     [
@@ -2105,31 +2061,32 @@ describe("uniswap decoder", () => {
                 );
                 expect(linesBetweenTokens(result)).toEqual([
                     ["Amount", "1000.0000 USDT"],
-                    ...lines,
                 ]);
             },
         );
 
-        // The lines of a PERMIT2_PERMIT of 600 USDT to the router whose
-        // amount does not stand.
-        const USDT_600_LINES = permitLines(
-            "600.0000 USDT",
-            USDT_ADDR,
-            "USDT",
-            ROUTER_ADDR,
-        );
-
-        // A PERMIT2_PERMIT_BATCH may raise what the router may take of the
-        // permit's token again, and its allowance gets lines of its own.
+        // A PERMIT2_PERMIT_BATCH, which this decoder does not read, may raise
+        // what the router may take of the permit's token again.
         test("a split after a PERMIT2_PERMIT and a PERMIT2_PERMIT_BATCH shows the total the steps take", () => {
+            const permitBatch = coder.encode(
+                [
+                    "tuple(tuple(address,uint160,uint48,uint48)[],address,uint256)",
+                    "bytes",
+                ],
+                [
+                    [
+                        [[USDT_ADDR, 10000000000n, 0, 0]], // 10,000 USDT
+                        ROUTER_ADDR,
+                        9999999999,
+                    ],
+                    "0x1234",
+                ],
+            );
             const result = decodeSteps(
                 [0x0a, 0x03, 0x00, 0x08],
                 [
                     encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
-                    encodePermit2Batch(
-                        [[USDT_ADDR, 10000000000n]], // 10,000 USDT
-                        ROUTER_ADDR,
-                    ),
+                    permitBatch,
                     V3_600,
                     encodeV2SwapExactIn(USER_ADDR, 9400000000n, 1n, [
                         USDT_ADDR,
@@ -2139,13 +2096,6 @@ describe("uniswap decoder", () => {
             );
             expect(linesBetweenTokens(result)).toEqual([
                 ["Amount", "10000.0000 USDT"],
-                ...USDT_600_LINES,
-                ...permitLines(
-                    "10000.0000 USDT",
-                    USDT_ADDR,
-                    "USDT",
-                    ROUTER_ADDR,
-                ),
             ]);
         });
 
@@ -2191,7 +2141,6 @@ describe("uniswap decoder", () => {
                 );
                 expect(linesBetweenTokens(result)).toEqual([
                     ["Amount", "10000.0000 USDT"],
-                    ...USDT_600_LINES,
                 ]);
             },
         );
@@ -2219,9 +2168,8 @@ describe("uniswap decoder", () => {
         ];
         // What a V3_SWAP_EXACT_OUT takes, at most its amountInMax, counts
         // as a V2_SWAP_EXACT_OUT's does, and the Amount line is a maximum.
-        // The permit of 10,000 USDT stands. The one of 600 USDT comes after
-        // the step that set the input side, so it does not stand and gets
-        // lines of its own.
+        // The permit of 10,000 USDT stands; the one of 600 USDT does not,
+        // because the step before it took its token.
         test.each([
             {
                 kind: "a V3 exact-in of 600 USDT, then a V3_SWAP_EXACT_OUT of at most 400 USDT",
@@ -2253,300 +2201,17 @@ describe("uniswap decoder", () => {
                     V3_600,
                 ],
                 amount: "Up to 10000.0000 USDT",
-                permit: USDT_600_LINES,
             },
         ])(
             "$kind, all paid by the user, shows the total as a maximum",
-            ({ commands, inputs, amount, permit = [] }) => {
+            ({ commands, inputs, amount }) => {
                 const result = decodeSteps(commands, inputs);
                 expect(linesBetweenTokens(result)).toEqual([
                     ["Amount", amount],
-                    ...permit,
                 ]);
             },
         );
 
-        // https://git.eeqj.de/sneak/AutistMask/issues/370 — a PERMIT2_PERMIT
-        // after the step that set the input side named Token In in place of
-        // that step's token, and its amount could stand as the Amount figure.
-        // Only a permit whose amount stands as the Amount figure names Token
-        // In now. Every other, before the swap steps or after them, leaves
-        // Token In and Amount as they read with no permit and gets lines of
-        // its own.
-        describe("a PERMIT2_PERMIT whose amount does not stand as the Amount figure", () => {
-            const DAI_5000 = 5000000000000000000000n;
-            const USDT_5000 = 5000000000n;
-            const MAX_UINT160 = 2n ** 160n - 1n;
-
-            test.each([
-                {
-                    kind: "a V3 exact-in of 600 USDT, then a PERMIT2_PERMIT of 5,000 DAI to the router,",
-                    commands: [0x00, 0x0a],
-                    inputs: [
-                        V3_600,
-                        encodePermit2(DAI_ADDR, DAI_5000, ROUTER_ADDR),
-                    ],
-                    lines: permitLines(
-                        "5000.0000 DAI",
-                        DAI_ADDR,
-                        "DAI",
-                        ROUTER_ADDR,
-                    ),
-                },
-                {
-                    kind: "a V3 exact-in of 600 USDT, then a PERMIT2_PERMIT of unlimited DAI to another spender,",
-                    commands: [0x00, 0x0a],
-                    inputs: [
-                        V3_600,
-                        encodePermit2(DAI_ADDR, MAX_UINT160, OTHER_ADDR),
-                    ],
-                    lines: permitLines(
-                        "Unlimited",
-                        DAI_ADDR,
-                        "DAI",
-                        OTHER_ADDR,
-                    ),
-                },
-                {
-                    kind: "a V3 exact-in of 600 USDT, then a PERMIT2_PERMIT of 600 USDT, the swap's own token, to the router,",
-                    commands: [0x00, 0x0a],
-                    inputs: [
-                        V3_600,
-                        encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
-                    ],
-                    lines: USDT_600_LINES,
-                },
-                {
-                    kind: "a PERMIT2_PERMIT of 5,000 USDT to another spender, then a V3 exact-in of 600 USDT,",
-                    commands: [0x0a, 0x00],
-                    inputs: [
-                        encodePermit2(USDT_ADDR, USDT_5000, OTHER_ADDR),
-                        V3_600,
-                    ],
-                    lines: permitLines(
-                        "5000.0000 USDT",
-                        USDT_ADDR,
-                        "USDT",
-                        OTHER_ADDR,
-                    ),
-                },
-                {
-                    kind: "a PERMIT2_PERMIT of 5,000 USDT to the router that the router may let fail, then a V3 exact-in of 600 USDT,",
-                    commands: [0x8a, 0x00],
-                    inputs: [
-                        encodePermit2(USDT_ADDR, USDT_5000, ROUTER_ADDR),
-                        V3_600,
-                    ],
-                    lines: permitLines(
-                        "5000.0000 USDT",
-                        USDT_ADDR,
-                        "USDT",
-                        ROUTER_ADDR,
-                    ),
-                },
-                {
-                    kind: "a PERMIT2_PERMIT of 5,000 DAI to another spender, then a V3 exact-in of 600 USDT,",
-                    commands: [0x0a, 0x00],
-                    inputs: [
-                        encodePermit2(DAI_ADDR, DAI_5000, OTHER_ADDR),
-                        V3_600,
-                    ],
-                    lines: permitLines(
-                        "5000.0000 DAI",
-                        DAI_ADDR,
-                        "DAI",
-                        OTHER_ADDR,
-                    ),
-                },
-                {
-                    kind: "a PERMIT2_PERMIT of 5,000 DAI to the router, a V3 exact-in of 600 USDT, then a PERMIT2_PERMIT of 600 USDT to the router,",
-                    commands: [0x0a, 0x00, 0x0a],
-                    inputs: [
-                        encodePermit2(DAI_ADDR, DAI_5000, ROUTER_ADDR),
-                        V3_600,
-                        encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
-                    ],
-                    lines: [
-                        ...permitLines(
-                            "5000.0000 DAI",
-                            DAI_ADDR,
-                            "DAI",
-                            ROUTER_ADDR,
-                        ),
-                        ...USDT_600_LINES,
-                    ],
-                },
-            ])(
-                "$kind shows the swap's 600 USDT and each permit's own lines",
-                ({ commands, inputs, lines }) => {
-                    const result = decodeSteps(commands, inputs);
-                    expect(result.name).toBe("Swap USDT → USDC");
-                    // The swap step names Token In, its address checksummed,
-                    // as on a permit's Allowance token line.
-                    expect(detail(result, "Token In").value).toBe(
-                        "USDT (" + USDT_ADDR + ")",
-                    );
-                    expect(linesBetweenTokens(result)).toEqual([
-                        ["Amount", "600.0000 USDT"],
-                        ...lines,
-                    ]);
-                    expect(detail(result, "Amount").rawValue).toBe("600.0000");
-                },
-            );
-
-            // With two permits neither amount stands, so the Amount line
-            // gives the total the steps take of USDT, the 400 DAI the last
-            // step takes gets lines of its own, and so does each permit.
-            test("a PERMIT2_PERMIT of USDT, a V3 exact-in of 600 USDT, a PERMIT2_PERMIT of DAI and a V2 exact-in of 400 DAI shows both tokens' amounts and each permit's own lines", () => {
-                const result = decodeSteps(
-                    [0x0a, 0x00, 0x0a, 0x08],
-                    [
-                        encodePermit2(USDT_ADDR, USDT_5000, ROUTER_ADDR),
-                        V3_600,
-                        encodePermit2(DAI_ADDR, DAI_400, ROUTER_ADDR),
-                        encodeV2SwapExactIn(USER_ADDR, DAI_400, 390000000n, [
-                            DAI_ADDR,
-                            USDC_ADDR,
-                        ]),
-                    ],
-                );
-                expect(result.name).toBe("Swap USDT → USDC");
-                expect(linesBetweenTokens(result)).toEqual([
-                    ["Amount", "600.0000 USDT"],
-                    ["Moved from the sender", "400.0000 DAI"],
-                    ["Token moved", "DAI (" + DAI_ADDR + ")"],
-                    ["Moved to", "The swap step that spends it"],
-                    ...permitLines(
-                        "5000.0000 USDT",
-                        USDT_ADDR,
-                        "USDT",
-                        ROUTER_ADDR,
-                    ),
-                    ...permitLines(
-                        "400.0000 DAI",
-                        DAI_ADDR,
-                        "DAI",
-                        ROUTER_ADDR,
-                    ),
-                ]);
-            });
-        });
-
-        // https://git.eeqj.de/sneak/AutistMask/issues/652 — a
-        // PERMIT2_PERMIT_BATCH, and a PERMIT2_PERMIT this decoder cannot read,
-        // showed nothing of what they allow. Each allowance a batch grants now
-        // gets the lines of a permit whose amount does not stand, and a permit
-        // or batch that cannot be read gets one line saying so and leaves no
-        // Amount figure.
-        describe("a PERMIT2_PERMIT_BATCH, or a permit that cannot be read", () => {
-            const USDT_5000 = 5000000000n;
-            const DAI_5000 = 5000000000000000000000n;
-            const MAX_UINT160 = 2n ** 160n - 1n;
-
-            // A batch names one spender for all its allowances.
-            test.each([
-                { kind: "the router", spender: ROUTER_ADDR },
-                { kind: "another spender", spender: OTHER_ADDR },
-            ])(
-                "a PERMIT2_PERMIT_BATCH of 5,000 USDT and unlimited DAI to $kind, then a V3 exact-in of 600 USDT, shows each allowance",
-                ({ spender }) => {
-                    const result = decodeSteps(
-                        [0x03, 0x00],
-                        [
-                            encodePermit2Batch(
-                                [
-                                    [USDT_ADDR, USDT_5000],
-                                    [DAI_ADDR, MAX_UINT160],
-                                ],
-                                spender,
-                            ),
-                            V3_600,
-                        ],
-                    );
-                    expect(result.name).toBe("Swap USDT → USDC");
-                    expect(linesBetweenTokens(result)).toEqual([
-                        ["Amount", "600.0000 USDT"],
-                        ...permitLines(
-                            "5000.0000 USDT",
-                            USDT_ADDR,
-                            "USDT",
-                            spender,
-                        ),
-                        ...permitLines("Unlimited", DAI_ADDR, "DAI", spender),
-                    ]);
-                    // A batch pays nobody, so the swap's minimum is what the
-                    // sender receives.
-                    expect(detail(result, "Paid to")).toBeUndefined();
-                    expect(detail(result, "Min. received").value).toBe(
-                        "590.0000 USDC",
-                    );
-                },
-            );
-
-            // A batch keeps a PERMIT2_PERMIT's amount from standing as the
-            // Amount figure, before the permit as after it.
-            test("a PERMIT2_PERMIT_BATCH of 5,000 DAI, then a PERMIT2_PERMIT of 5,000 USDT to the router and a V3 exact-in of 600 USDT, shows the swap's 600 USDT and both permits' lines", () => {
-                const result = decodeSteps(
-                    [0x03, 0x0a, 0x00],
-                    [
-                        encodePermit2Batch([[DAI_ADDR, DAI_5000]], ROUTER_ADDR),
-                        encodePermit2(USDT_ADDR, USDT_5000, ROUTER_ADDR),
-                        V3_600,
-                    ],
-                );
-                expect(linesBetweenTokens(result)).toEqual([
-                    ["Amount", "600.0000 USDT"],
-                    ...permitLines(
-                        "5000.0000 DAI",
-                        DAI_ADDR,
-                        "DAI",
-                        ROUTER_ADDR,
-                    ),
-                    ...permitLines(
-                        "5000.0000 USDT",
-                        USDT_ADDR,
-                        "USDT",
-                        ROUTER_ADDR,
-                    ),
-                ]);
-            });
-
-            // The permit's token word, and the batch's spender word, have a
-            // nonzero top byte.
-            test.each([
-                {
-                    kind: "a PERMIT2_PERMIT",
-                    command: 0x0a,
-                    input: dirtyWord(
-                        encodePermit2(USDT_ADDR, USDT_5000, ROUTER_ADDR),
-                        0,
-                    ),
-                },
-                {
-                    kind: "a PERMIT2_PERMIT_BATCH",
-                    command: 0x03,
-                    input: dirtyWord(
-                        encodePermit2Batch(
-                            [[USDT_ADDR, USDT_5000]],
-                            ROUTER_ADDR,
-                        ),
-                        3,
-                    ),
-                },
-            ])(
-                "$kind that cannot be read, then a V3 exact-in of 600 USDT, says its allowances could not be decoded and shows no Amount figure",
-                ({ command, input }) => {
-                    const result = decodeSteps(
-                        [command, 0x00],
-                        [input, V3_600],
-                    );
-                    expect(linesBetweenTokens(result)).toEqual([
-                        ["Permit2 allowance", UNDECODED],
-                    ]);
-                },
-            );
-        });
-
         // A V3_SWAP_EXACT_OUT whose path is shorter than one token cannot be
         // read. It may pay any address and take from the sender, so it
         // leaves no Amount figure.
@@ -2592,7 +2257,7 @@ describe("uniswap decoder", () => {
         // A V3 exact-out of 1,500 USDC for at most 0.5 WETH spends WETH, not
         // SPK. After it, a PERMIT2_PERMIT of 1 WETH and a V3 exact-in of 0.5
         // WETH: the permit's amount does not stand, because the step before
-        // it also takes WETH, so the permit gets lines of its own.
+        // it also takes WETH.
         test("a V3_SWAP_EXACT_OUT whose path has bytes after its last hop, then a PERMIT2_PERMIT and a V3 exact-in, shows no Amount figure", () => {
             const path = pathEndingIn([USDC_ADDR, WETH_ADDR], SPK_ADDR);
             const result = decodeSteps(
@@ -2608,7 +2273,6 @@ describe("uniswap decoder", () => {
             );
             expect(linesBetweenTokens(result)).toEqual([
                 ["Moved from the sender", UNDECODED],
-                ...permitLines("1.0000 WETH", WETH_ADDR, "WETH", ROUTER_ADDR),
             ]);
             expect(detail(result, "Paid to").value).toBe(UNDECODED);
         });
@@ -2779,11 +2443,7 @@ describe("uniswap decoder", () => {
                     V4_EXACT_OUT_600,
                     V2_EXACT_OUT_400,
                 ],
-                lines: [
-                    ...UNKNOWN_USDT,
-                    ...UP_TO_400_USDT,
-                    ...ONE_USDT_LINES(OTHER_ADDR),
-                ],
+                lines: [...UNKNOWN_USDT, ...UP_TO_400_USDT],
             },
             {
                 kind: "a V4 step whose swap action cannot be read, with a SETTLE of WETH by the user, then a V2 exact-out of at most 400 USDT",
@@ -3409,7 +3069,9 @@ describe("uniswap decoder", () => {
         );
         const result = uniswap.decode(data, ROUTER_ADDR, "0x1", {}, USER_ADDR);
         expect(result.name).toBe("Uniswap Swap");
-        expect(detail(result, "Token In").address).toBe(USDT_ADDR);
+        expect(detail(result, "Token In").address).toBe(
+            USDT_ADDR.toLowerCase(),
+        );
         expect(detail(result, "Amount").value).toBe("1000.0000 USDT");
         expect(detail(result, "Token Out").value).toBe(
             "Unknown (not named in the calldata)",
@@ -3467,7 +3129,9 @@ describe("uniswap decoder", () => {
             "Unknown (not named in the calldata)",
         );
         expect(detail(result, "Amount")).toBeUndefined();
-        expect(detail(result, "Token Out").address).toBe(USDT_ADDR);
+        expect(detail(result, "Token Out").address).toBe(
+            USDT_ADDR.toLowerCase(),
+        );
         expect(detail(result, "Min. received").value).toBe("990.0000 USDT");
     });
 

tests/uniswapRecipient.test.js

@@ -11,8 +11,7 @@
 // what each PERMIT2_TRANSFER_FROM moves
 // (https://git.eeqj.de/sneak/AutistMask/issues/611), and when an
 // UNWRAP_WETH makes the output ETH
-// (https://git.eeqj.de/sneak/AutistMask/issues/607 and
-// https://git.eeqj.de/sneak/AutistMask/issues/642).
+// (https://git.eeqj.de/sneak/AutistMask/issues/607).
 //
 // Every swap command, SWEEP, WRAP_ETH, UNWRAP_WETH, TRANSFER, PAY_PORTION,
 // PAY_PORTION_FULL_PRECISION, PERMIT2_TRANSFER_FROM, ACROSS_V4_DEPOSIT_V3 and
@@ -746,365 +745,6 @@ describe("an UNWRAP_WETH makes the output ETH only when the router holds it", ()
     });
 });
 
-// https://git.eeqj.de/sneak/AutistMask/issues/642: a step between the swap and
-// the UNWRAP_WETH may take WETH out of the router or pay it WETH, and a step
-// after an UNWRAP_WETH into the router may pay its ETH out as WETH, yet each
-// route read as ETH with the swap's minimum. A step the decoder read that is a
-// PERMIT2_PERMIT, a BALANCE_CHECK_ERC20, or a SWEEP, TRANSFER, PAY_PORTION or
-// PAY_PORTION_FULL_PRECISION of a token other than WETH, and not of ETH to a
-// WETH contract, cannot take WETH out of the router or pay anyone WETH; the
-// decoder treats every other step as one that may.
-describe("what reaches the UNWRAP_WETH of the swap's WETH", () => {
-    const NO_MINIMUM_TO_USER = PAID_TO_USER.filter(
-        (l) => l !== "Min. received",
-    );
-    const NO_MINIMUM_ELSEWHERE = PAID_ELSEWHERE.filter(
-        (l) => l !== "Min. paid out",
-    );
-
-    test.each([
-        {
-            kind: "a TRANSFER of 0.0025 WETH",
-            step: transfer(0x05, WETH, OTHER, ONE_WETH / 400n),
-        },
-        {
-            kind: "a PAY_PORTION of 25 bips",
-            step: transfer(0x06, WETH, OTHER, 25n),
-        },
-        {
-            kind: "a PAY_PORTION_FULL_PRECISION of 1e15",
-            step: transfer(0x07, WETH, OTHER, 10n ** 15n),
-        },
-    ])(
-        "$kind to another address between them reads as ETH with no minimum",
-        ({ step }) => {
-            const result = decode(
-                execute(swapToWeth(ADDRESS_THIS), step, unwrapWeth(MSG_SENDER)),
-                USER,
-                ROUTER_V2_1_2,
-            );
-            expect(result.name).toBe("Swap USDT → ETH");
-            expect(labels(result)).toEqual(NO_MINIMUM_ELSEWHERE);
-            expect(paidTo(result)).toEqual([OTHER]);
-        },
-    );
-
-    test.each([
-        {
-            kind: "a SWEEP whose recipient cannot be read",
-            step: withDirtyWord(sweep(WETH, OTHER), 1),
-        },
-        {
-            kind: "a V4 SETTLE of 0.5 WETH from the router",
-            step: v4Swap([
-                0x0b,
-                coder.encode(
-                    ["address", "uint256", "bool"],
-                    [WETH, ONE_WETH / 2n, false],
-                ),
-            ]),
-        },
-        {
-            kind: "a bridge deposit of 0.5 WETH",
-            step: acrossDeposit(USER, USER, WETH, ONE_WETH / 2n),
-        },
-        {
-            kind: "a PERMIT2_TRANSFER_FROM of 0.5 WETH into the router",
-            step: permit2TransferFrom(WETH, ADDRESS_THIS, ONE_WETH / 2n),
-        },
-    ])("$kind between them reads as ETH with no minimum", ({ step }) => {
-        const result = decode(
-            execute(swapToWeth(ADDRESS_THIS), step, unwrapWeth(MSG_SENDER)),
-        );
-        expect(result.name).toBe("Swap USDT → ETH");
-        expect(detail(result, "Min. received")).toBeUndefined();
-        expect(detail(result, "Min. paid out")).toBeUndefined();
-    });
-
-    test.each([
-        {
-            kind: "a PERMIT2_PERMIT between them",
-            steps: [permit2Permit(USDT, USDT_2000), unwrapWeth(MSG_SENDER)],
-        },
-        {
-            kind: "a BALANCE_CHECK_ERC20 of another address between them",
-            steps: [balanceCheck(USDC, 1n, OTHER), unwrapWeth(MSG_SENDER)],
-        },
-        {
-            kind: "a BALANCE_CHECK_ERC20 of the sender with a zero minimum between them",
-            steps: [balanceCheck(USDC, 0n), unwrapWeth(MSG_SENDER)],
-        },
-        {
-            kind: "a SWEEP of USDC between them",
-            steps: [sweep(USDC, MSG_SENDER), unwrapWeth(MSG_SENDER)],
-        },
-        {
-            kind: "an UNWRAP_WETH into the router, then a SWEEP of its ETH,",
-            steps: [unwrapWeth(ADDRESS_THIS), sweep(ZERO, MSG_SENDER)],
-        },
-    ])("$kind reads as ETH with the swap's minimum", ({ steps }) => {
-        const result = decode(execute(swapToWeth(ADDRESS_THIS), ...steps));
-        expect(result.name).toBe("Swap USDT → ETH");
-        expect(detail(result, "Min. received").value).toBe("1.0000 ETH");
-    });
-
-    test("a V4 step that TAKEs its WETH to the router, then an UNWRAP_WETH to the user, reads as ETH with the swap's minimum", () => {
-        const result = decode(
-            execute(
-                v4Swap(
-                    SWAP_USDT_FOR_WETH,
-                    SETTLE_USDT,
-                    take(WETH, ADDRESS_THIS),
-                ),
-                unwrapWeth(MSG_SENDER),
-            ),
-        );
-        expect(result.name).toBe("Swap USDT → ETH");
-        expect(detail(result, "Min. received").value).toBe("1.0000 ETH");
-    });
-
-    test.each([
-        {
-            kind: "a TRANSFER of 100 USDC",
-            step: transfer(0x05, USDC, OTHER, 100000000n),
-        },
-        {
-            kind: "a PAY_PORTION of 25 bips of USDC",
-            step: transfer(0x06, USDC, OTHER, 25n),
-        },
-        {
-            kind: "a PAY_PORTION_FULL_PRECISION of 1e15 of USDC",
-            step: transfer(0x07, USDC, OTHER, 10n ** 15n),
-        },
-    ])(
-        "$kind to another address between them reads as ETH with the swap's minimum",
-        ({ step }) => {
-            const result = decode(
-                execute(swapToWeth(ADDRESS_THIS), step, unwrapWeth(MSG_SENDER)),
-                USER,
-                ROUTER_V2_1_2,
-            );
-            expect(result.name).toBe("Swap USDT → ETH");
-            expect(paidTo(result)).toEqual([OTHER]);
-            expect(detail(result, "Min. paid out").value).toBe("1.0000 ETH");
-        },
-    );
-
-    test.each([
-        {
-            kind: "a TRANSFER of 0.0025 ETH",
-            step: transfer(0x05, ZERO, OTHER, ONE_WETH / 400n),
-        },
-        {
-            kind: "a PAY_PORTION of 25 bips of its ETH",
-            step: transfer(0x06, ZERO, OTHER, 25n),
-        },
-        {
-            kind: "a PAY_PORTION_FULL_PRECISION of 1e15 of its ETH",
-            step: transfer(0x07, ZERO, OTHER, 10n ** 15n),
-        },
-    ])(
-        "an UNWRAP_WETH into the router, then $kind to another address, then a SWEEP of its ETH to the user, reads as ETH with the swap's minimum",
-        ({ step }) => {
-            const result = decode(
-                execute(
-                    swapToWeth(ADDRESS_THIS),
-                    unwrapWeth(ADDRESS_THIS),
-                    step,
-                    sweep(ZERO, MSG_SENDER),
-                ),
-                USER,
-                ROUTER_V2_1_2,
-            );
-            expect(result.name).toBe("Swap USDT → ETH");
-            expect(paidTo(result)).toEqual([OTHER]);
-            expect(detail(result, "Min. paid out").value).toBe("1.0000 ETH");
-        },
-    );
-
-    // The SWEEP pays the user the swap's WETH, so the UNWRAP_WETH unwraps the
-    // WRAP_ETH's.
-    test("a SWEEP of the swap's WETH to the user, then a WRAP_ETH into the router, reads as ETH with no minimum", () => {
-        const result = decode(
-            execute(
-                swapToWeth(ADDRESS_THIS),
-                sweep(WETH, MSG_SENDER),
-                wrapEth(ADDRESS_THIS, ONE_WETH),
-                unwrapWeth(MSG_SENDER),
-            ),
-        );
-        expect(result.name).toBe("Swap USDT → ETH");
-        expect(labels(result)).toEqual(NO_MINIMUM_TO_USER);
-    });
-
-    test("an UNWRAP_WETH into the router, then a WRAP_ETH of all its ETH to the user, reads as WETH with no minimum", () => {
-        const result = decode(
-            execute(
-                swapToWeth(ADDRESS_THIS),
-                unwrapWeth(ADDRESS_THIS),
-                wrapEth(MSG_SENDER, CONTRACT_BALANCE),
-            ),
-        );
-        expect(result.name).toBe("Swap USDT → WETH");
-        expect(labels(result)).toEqual(NO_MINIMUM_TO_USER);
-    });
-
-    // The router reads the recipient from the last 20 bytes of its word,
-    // here address(2), the router itself.
-    test("an UNWRAP_WETH whose recipient cannot be read, then a WRAP_ETH of all the router's ETH to the user, reads as WETH with no minimum", () => {
-        const result = decode(
-            execute(
-                swapToWeth(ADDRESS_THIS),
-                withDirtyWord(unwrapWeth(ADDRESS_THIS), 0),
-                wrapEth(MSG_SENDER, CONTRACT_BALANCE),
-            ),
-        );
-        expect(result.name).toBe("Swap USDT → WETH");
-        expect(detail(result, "Min. received")).toBeUndefined();
-        expect(detail(result, "Min. paid out")).toBeUndefined();
-    });
-
-    // The first UNWRAP_WETH may pay the router the swap's output as ETH, and
-    // the WRAP_ETH to the user pays all of it out as WETH, so the last
-    // UNWRAP_WETH finds none of it.
-    test.each([
-        {
-            kind: "an UNWRAP_WETH whose recipient cannot be read, then a WRAP_ETH of all the router's ETH to the user",
-            steps: [
-                withDirtyWord(unwrapWeth(ADDRESS_THIS), 0),
-                wrapEth(MSG_SENDER, CONTRACT_BALANCE),
-            ],
-        },
-        {
-            kind: "an UNWRAP_WETH into the router, a WRAP_ETH of all its ETH to the user, then a WRAP_ETH of all its ETH into the router",
-            steps: [
-                unwrapWeth(ADDRESS_THIS),
-                wrapEth(MSG_SENDER, CONTRACT_BALANCE),
-                wrapEth(ADDRESS_THIS, CONTRACT_BALANCE),
-            ],
-        },
-    ])(
-        "$kind, then an UNWRAP_WETH to the user, reads as WETH with no minimum",
-        ({ steps }) => {
-            const result = decode(
-                execute(
-                    swapToWeth(ADDRESS_THIS),
-                    ...steps,
-                    unwrapWeth(MSG_SENDER),
-                ),
-            );
-            expect(result.name).toBe("Swap USDT → WETH");
-            expect(detail(result, "Min. received")).toBeUndefined();
-            expect(detail(result, "Min. paid out")).toBeUndefined();
-        },
-    );
-
-    // A SWEEP of WETH pays out WETH, and ETH paid to a WETH contract pays the
-    // router WETH for it. The decoder treats each as a step that may pay out
-    // as WETH the swap's output, which the router holds as ETH.
-    test.each([
-        {
-            kind: "a SWEEP of WETH to the user",
-            step: sweep(WETH, MSG_SENDER),
-        },
-        {
-            kind: "a SWEEP of its ETH to the WETH contract",
-            step: sweep(ZERO, WETH),
-        },
-        {
-            kind: "a TRANSFER of 0.5 ETH to the WETH contract",
-            step: transfer(0x05, ZERO, WETH, ONE_WETH / 2n),
-        },
-        {
-            kind: "a PAY_PORTION of all its ETH to the WETH contract",
-            step: transfer(0x06, ZERO, WETH, 10000n),
-        },
-    ])(
-        "an UNWRAP_WETH into the router, then $kind, reads as WETH with no minimum",
-        ({ step }) => {
-            const result = decode(
-                execute(
-                    swapToWeth(ADDRESS_THIS),
-                    unwrapWeth(ADDRESS_THIS),
-                    step,
-                ),
-            );
-            expect(result.name).toBe("Swap USDT → WETH");
-            expect(detail(result, "Min. received")).toBeUndefined();
-            expect(detail(result, "Min. paid out")).toBeUndefined();
-        },
-    );
-
-    // The user receives 0.5 WETH and the rest of the swap's output as ETH.
-    test("an UNWRAP_WETH into the router, then a WRAP_ETH of 0.5 ETH to the user, reads as WETH with no minimum", () => {
-        const result = decode(
-            execute(
-                swapToWeth(ADDRESS_THIS),
-                unwrapWeth(ADDRESS_THIS),
-                wrapEth(MSG_SENDER, ONE_WETH / 2n),
-                sweep(ZERO, MSG_SENDER),
-            ),
-        );
-        expect(result.name).toBe("Swap USDT → WETH");
-        expect(labels(result)).toEqual(NO_MINIMUM_TO_USER);
-    });
-
-    // The UNWRAP_WETH pays the user the swap's WETH as ETH; the WRAP_ETH wraps
-    // the ETH an earlier V4 step paid the router.
-    test("an UNWRAP_WETH to the user, then a WRAP_ETH of all the router's ETH to the user, reads as ETH", () => {
-        const result = decode(
-            execute(
-                v4Swap(
-                    SWAP_USDT_FOR_ETH,
-                    SETTLE_USDT,
-                    take(ZERO, ADDRESS_THIS),
-                ),
-                swapToWeth(ADDRESS_THIS),
-                unwrapWeth(MSG_SENDER),
-                wrapEth(MSG_SENDER, CONTRACT_BALANCE),
-            ),
-        );
-        expect(detail(result, "Token Out").value).toBe("ETH");
-        expect(detail(result, "Min. received").value).toBe("1.0000 ETH");
-    });
-
-    // The first swap is for at least 0.5 WETH and the second for at least
-    // 1 WETH. The second sets the output side again, so the first
-    // UNWRAP_WETH into the router no longer bears on it.
-    test.each([
-        { kind: "a V3 swap step", step: swapToWeth(ADDRESS_THIS) },
-        {
-            kind: "a V4 step that TAKEs its WETH to the router",
-            step: v4Swap(
-                SWAP_USDT_FOR_WETH,
-                SETTLE_USDT,
-                take(WETH, ADDRESS_THIS),
-            ),
-        },
-    ])(
-        "a swap paying WETH to the router, an UNWRAP_WETH into the router, a SWEEP of its ETH to the user, then $kind and an UNWRAP_WETH to the user, reads as ETH with the second swap's minimum",
-        ({ step }) => {
-            const result = decode(
-                execute(
-                    v3SwapExactIn(
-                        ADDRESS_THIS,
-                        USDT_2000,
-                        ONE_WETH / 2n,
-                        USDT,
-                        WETH,
-                    ),
-                    unwrapWeth(ADDRESS_THIS),
-                    sweep(ZERO, MSG_SENDER),
-                    step,
-                    unwrapWeth(MSG_SENDER),
-                ),
-            );
-            expect(result.name).toBe("Swap USDT → ETH");
-            expect(detail(result, "Min. received").value).toBe("1.0000 ETH");
-        },
-    );
-});
-
 // https://git.eeqj.de/sneak/AutistMask/issues/606: any token a step pays the
 // router stays there unless a later step pays out or spends all of it, not
 // only the swap's output. A V4 SETTLE can take more of the user's tokens than
@@ -2071,6 +1711,15 @@ describe("a payout of part of the router's output", () => {
             ),
             min: "1.0000 WETH",
         },
+        {
+            kind: "PAY_PORTION of 25 bips, then UNWRAP_WETH",
+            data: execute(
+                swapToWeth(ADDRESS_THIS),
+                transfer(0x06, WETH, OTHER, 25n),
+                unwrapWeth(MSG_SENDER),
+            ),
+            min: "1.0000 ETH",
+        },
         {
             kind: "V4 TAKE_PORTION of 25 bips, then TAKE_ALL",
             data: execute(
@@ -2809,7 +2458,7 @@ describe("the allow-revert flag", () => {
             mark: " (allowed to fail)",
         },
     ])(
-        "on $router, a PERMIT2_PERMIT with the flag is listed as 'Permit2 Permit$mark', and the swap's lines read as without the flag",
+        "on $router, a PERMIT2_PERMIT with the flag is listed as 'Permit2 Permit$mark', and the swap reads as without the flag",
         ({ address, mark }) => {
             const steps = [
                 permit2Permit(USDT, USDT_2000),
@@ -2824,24 +2473,9 @@ describe("the allow-revert flag", () => {
             expect(detail(withFlag, "Steps").value).toBe(
                 "Permit2 Permit" + mark + " → V3 Swap (Exact In)",
             );
-            // The permit names the router at ROUTER as its spender, so its
-            // amount stands as the Amount figure only there, and only without
-            // the flag. With the flag it stands on no router and gets lines
-            // of its own, and the swap step names Token In: the same token,
-            // its address written the same way.
-            const permitLines = [
-                "Permit2 allowance",
-                "Allowance token",
-                "Allowance spender",
-            ];
-            const swapLines = (r) =>
-                r.details.filter(
-                    (d) => !["Steps", ...permitLines].includes(d.label),
-                );
-            expect(swapLines(withFlag)).toEqual(swapLines(plain));
-            expect(
-                labels(withFlag).filter((l) => permitLines.includes(l)),
-            ).toEqual(permitLines);
+            const withoutSteps = (r) =>
+                r.details.filter((d) => d.label !== "Steps");
+            expect(withoutSteps(withFlag)).toEqual(withoutSteps(plain));
             expect(detail(withFlag, "Min. received").value).toBe("1.0000 WETH");
         },
     );