fix: an open popup follows a network switch the background saves (closes #650)

When the background saves a network switch after the user approves a
site's request, or another popup page saves one, an open popup takes the
new network from the stored record inside a save, holding the lock, and
checks the record once at start-up for a switch saved before it
listened. It then leaves the page as a switch in Settings does: the cut
and the redraw are two Settings functions both paths call, and both
reset the popup's caches through one function. A switch in Settings is
now made inside its own save too, so one picked while a follow waits for
the lock is made after it. The popup never switches the network itself.

Model: opus-5-5

README.md

@@ -845,7 +845,7 @@ src/
     views/            — one JS module per screen (home, send, approval, etc.)
   shared/             — modules used by both popup and background
     alarms.js         — recurring background jobs (extension alarms API)
-    balances.js       — ETH and tracked token balances via RPC, others via Blockscout
+    balances.js       — ETH + ERC-20 balance fetching via RPC + Blockscout
     constants.js      — chain IDs, default RPC endpoint, ERC-20 ABI
     ens.js            — ENS forward/reverse resolution (popup only)
     holders.js        — holder-count parsing and the low-holder rule
@@ -1173,8 +1173,8 @@ fetched, without that cross-address check, and shows the row's figure.
 **Decoded amount lines on the transaction approval screen:** the `Amount` line
 of a decoded ERC-20 call, and the `Amount` and `Min. received` lines of a
 decoded swap (see TxApproval below; `Min. received` reads `Min. paid out` unless
-only the user is paid and no allowance goes to a spender other than the router,
+only the user is paid, see Transaction Decoding), do not always read as a
-see Transaction Decoding), do not always read as a number. They can read:
+number. They can read:
 
 - A formatted quantity, e.g. `17.1900 USDT`, when the token's scale is known:
   truncated to four decimals, with the floor and the zero cases described above.
@@ -1243,11 +1243,7 @@ only when no earlier step set it. It finds each side by three rules:
    is their sum; in any other case the step gives no `Amount`. The decoder reads
    no amount from an exact-out action, and an open delta is not a stated amount.
    Its `Min. received` is found the same way, from the `amountOutMin` of the
-   actions that buy the output currency, except that the step gives none when a
+   actions that buy the output currency.
-   swap action in it also spends the output currency, because the step then does
-   not pay out all that those actions buy. A step that buys at least 0.5 WETH
-   with USDT and swaps 0.3 WETH of it for USDC, with WETH as its output side,
-   gives no `Min. received`.
 3. If any swap action in the step could not be read, only `SETTLE`,
    `SETTLE_ALL`, `TAKE` and `TAKE_ALL` name its sides, and the step gives no
    `Amount` or `Min. received`. A side they did not name is unknown, and the
@@ -1379,30 +1375,23 @@ The core hierarchy is **Wallets → Addresses**:
 - The user can have multiple wallets, each with multiple addresses (HD) or a
   single address (key).
 
-Which tokens an address shows is decided on every refresh by `refreshBalances()`
+Which tokens an address shows is decided by `fetchTokenBalances()` in
-in `src/shared/balances.js`. The balance of each token tracked on the active
+`src/shared/balances.js`, from the Blockscout `token-balances` response, so
-network is read with `balanceOf` through the RPC endpoint, for every address.
+tokens do appear without the user adding them. An ERC-20 is shown when its
-Its holder count and `decimals` are those of Blockscout's entry for it in the
+balance is nonzero and it is in the bundled known-token list, is tracked by the
-same refresh, kept from before while Blockscout fails. A read that fails keeps
+user, or has 1,000 or more holders; a token claiming a symbol from the bundled
-that token's previous entry, as a failed ETH balance keeps its figure, or takes
+list from any other contract address is always dropped, and so is any token
-Blockscout's entry from the same refresh when there is none. Every other token
+claiming a symbol that belongs to the native asset and therefore has no
-comes from the Blockscout `token-balances` response (`fetchTokenBalances()`), so
+legitimate contract at all (`"ETH"`, and every network's `nativeCurrency`, such
-tokens do appear without the user adding them, and they keep their previous
+as `"SepoliaETH"`, on every network). That filter is unconditional — the "Hide
-figures while Blockscout fails. A tracked token is shown when its balance is
+tokens with fewer than 1,000 holders" setting governs the transaction history
-nonzero, and any other ERC-20 when its balance is nonzero and it is in the
+and the send-screen token selector, not this list. A token's holder count is
-bundled known-token list or has 1,000 or more holders. A token claiming a symbol
+unknown when the explorer reports none, or reports anything other than a whole
-from the bundled list from any other contract address is always dropped, tracked
+number written in digits alone, such as `1,000` or `1e3` (`parseHoldersCount()`
-or not, and so is any token claiming a symbol that belongs to the native asset
+in `src/shared/holders.js`). This list does not take an unknown count as 1,000
-and therefore has no legitimate contract at all (`"ETH"`, and every network's
+or more, so such a token is shown only when it is on the bundled list or
-`nativeCurrency`, such as `"SepoliaETH"`, on every network). That filter is
+tracked. `fetchTokenBalances()` stores every nonzero holding of a token it
-unconditional — the "Hide tokens with fewer than 1,000 holders" setting governs
+admits, however small, but a holding below 0.000001 is left out of the balance
-the transaction history and the send-screen token selector, not this list. A
-token's holder count is unknown when the explorer reports none, or reports
-anything other than a whole number written in digits alone, such as `1,000` or
-`1e3` (`parseHoldersCount()` in `src/shared/holders.js`). This list does not
-take an unknown count as 1,000 or more, so such a token is shown only when it is
-on the bundled list or tracked. Every nonzero holding of a token shown is stored
-exactly, however small, but a holding below 0.000001 is left out of the balance
 lists, the send-screen token selector, the address total and the remove-address
 warning (`isBelowOneMillionth()` in `src/shared/amountDisplay.js`). The Send and
 confirmation screens show it when its token is the one being sent. Tracked
@@ -2451,11 +2440,10 @@ view would leave a wallet one click from deletion.
     - 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` whose amount is not the `Amount` figure lets its spender
-      `PERMIT2_PERMIT_BATCH`, lets its spender take, steps, deadline, and unless
+      take, steps, deadline, and unless a swap pays only the From address, a
-      a swap pays only the From address, a `Paid to` line for each other address
+      `Paid to` line for each other address it pays, or saying that a token
-      it pays, or saying that a token stays in the router or who it pays is
+      stays in the router or who it pays is unknown (see Transaction Decoding)
-      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
@@ -2669,8 +2657,7 @@ AutistMask is not a fully self-contained offline tool. It necessarily
 communicates with three external services to function as a wallet:
 
 - **Ethereum JSON-RPC endpoint**: The extension needs an Ethereum node to query
-  balances (`eth_getBalance`), read ERC-20 token contracts (`eth_call`), among
+  balances (`eth_getBalance`), read ERC-20 token contracts (`eth_call`),
-  them the balance of every tracked token at every address (`balanceOf`),
   estimate gas (`eth_estimateGas`), fetch nonces (`eth_getTransactionCount`),
   broadcast transactions (`eth_sendRawTransaction`), and check transaction
   receipts. The default endpoint is a public RPC (configurable by the user to
@@ -3209,9 +3196,8 @@ Currently supported:
   `Min. paid out`, because the swap's minimum includes the fee. The minimum
   reads `Min. received` only when some step pays the transaction's sender (the
   From address on TxApproval, the sender the explorer reports on
-  TransactionDetail), no `Paid to` line is shown, and no permit or batch grants
+  TransactionDetail) and no `Paid to` line is shown. `Paid to` lines after
-  an allowance to a spender other than the router (see below). `Paid to` lines
+  `Token Out` name each other address paid; one reads
-  after `Token Out` name each other address paid; one reads
   `The bridge, which pays the deposit's recipient on another network` for a
   bridge deposit; one reads, for example,
   `The router, 2000.0000 USDT from the sender (later steps may not spend all of it)`
@@ -3250,55 +3236,38 @@ Currently supported:
   `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,
+  transaction, its spender is the router, the router may not let it fail, no
-  the router may not let it fail, no step before it takes its token, a
+  step before it takes its token or a token the decoder does not know, and the
-  `PERMIT2_TRANSFER_FROM` of it included, or a token the decoder does not know,
+  decoder reads every step after it in full. Permit2 then lets the router take
-  and the decoder reads every step after it in full. Permit2 then lets the
+  no more of the token than that amount, so the permit covers every take of it.
-  router take no more of the token than that amount, so the permit covers every
+  A step the decoder does not read in full may raise what Permit2 lets the
-  take of it. A step before the permit takes under whatever allowance the router
+  router take, as a `PERMIT2_PERMIT_BATCH` can: a command the decoder does not
-  already had, so it may take more than the permit's amount, which would then
+  read (listed at the end of this section), a step whose input it cannot read,
-  read lower than what leaves the user's wallet: a `PERMIT2_TRANSFER_FROM` of
+  in whole or in part, and a step it fails on. Every other `PERMIT2_PERMIT`,
-  2,000 USDT into the router, then a permit of 600 USDT to the router and a V3
+  before the step that sets the input side or after it, leaves `Token In` and
-  exact-in of 2,000 USDT paid from the router, read `Amount 2000.0000 USDT`. A
+  the `Amount` line as they read with no permit: a permit of 5,000 DAI to
-  later permit or batch may raise what Permit2 lets the router take, and so may
+  another address and then a V3 exact-in of 600 USDT read `Swap USDT → USDC`
-  a step the decoder does not read in full: a command the decoder does not read
+  with `Amount 600.0000 USDT`, and so do that exact-in and then a permit of
-  (listed at the end of this section), a step whose input it cannot read, in
+  5,000 DAI to the router. When a permit's amount stands and the step that sets
-  whole or in part, and a step it fails on. Every other `PERMIT2_PERMIT`, before
+  the input side spends a token other than the permit's, or one the decoder does
-  the step that sets the input side or after it, leaves `Token In` and the
+  not know, that step's amount gets lines of its own, unless it states no amount
-  `Amount` line as they read with no permit, unless it lets a spender other than
+  and the user pays it none of its input token. Each take the total does not
-  the router take `Token In` (see below): a permit of 5,000 DAI to another
+  count gives three lines after the `Amount` line (after `Token In` when there
-  address and then a V3 exact-in of 600 USDT read `Swap USDT → USDC` with
+  is none): one of a token other than `Token In`; one of `Token In` after an
-  `Amount 600.0000 USDT`, and so do that exact-in and then a permit of 5,000 DAI
+  amount that is not a quantity (a V4 open delta, `ALREADY_PAID`, which keep
-  to the router. When a permit's amount stands and the step that sets the input
+  their wording on the `Amount` line, or no stated amount, as of a V4 exact-out
-  side spends a token other than the permit's, or one the decoder does not know,
+  step); and one whose amount the decoder does not know. When the step that sets
-  that step's amount gets lines of its own, unless it states no amount and the
+  the input side states no amount, the user pays it some of its input token, and
-  user pays it none of its input token. Each take the total does not count gives
+  there is no `Amount` line, that step gets them too whenever another take's
-  three lines after the `Amount` line (after `Token In` when there is none): one
+  lines give a figure, or a `PERMIT2_TRANSFER_FROM` of its token gives one, on
-  of a token other than `Token In`; one of `Token In` after an amount that is
+  the lines below or, into the router, on its `Paid to` line, so that figure
-  not a quantity (a V4 open delta, `ALREADY_PAID`, which keep their wording on
+  cannot read as all that leaves. When it states no amount and the user pays it
-  the `Amount` line, or no stated amount, as of a V4 exact-out step); and one
+  none of its input token, as when the router pays it, that step takes none of
-  whose amount the decoder does not know. When there is no `Amount` line, each
+  that token from the user's wallet and never gets them, with a permit or
-  take the total counts gets them too, so that every amount the decoder reads is
+  without. They come in step order, the step that sets the input side first when
-  shown: the amount the step that sets the input side states, when it is a
+  it has them: `Moved from the sender`, its amount, worded as the `Amount` line
-  quantity and the user pays that step (a V2 or V3 step whose `payerIsUser` is
+  words one, or `Unknown (could not be decoded)` when the decoder does not know
-  true, a V4 step the user pays some of its input token, or a `WRAP_ETH`, whose
+  it; `Token moved`, giving the token's address as the `Token In` line does; and
-  ETH comes from the transaction's value), and each later take of `Token In`
-  added to it. A step that sets the input side and is paid from the router takes
-  nothing from the user's wallet and gets none. A `PERMIT2_PERMIT` the decoder
-  cannot read, then V3 exact-ins of 600 USDT and 400 DAI paid by the user, give
-  lines for both amounts. When the step that sets the input side states no
-  amount, the user pays it some of its input token, and there is no `Amount`
-  line, that step gets them too whenever another take's lines give a figure, or
-  a `PERMIT2_TRANSFER_FROM` of its token gives one, on the lines below or, into
-  the router, on its `Paid to` line, so that figure cannot read as all that
-  leaves. When it states no amount and the user pays it none of its input token,
-  as when the router pays it, that step takes none of that token from the user's
-  wallet and never gets them, with a permit or without. They come in step order,
-  except that the step that sets the input side comes first when it has them,
-  followed, when there is no `Amount` line, by the other takes the total counts:
-  `Moved from the sender`, its amount, worded as the `Amount` line words one, or
-  `Unknown (could not be decoded)` when the decoder does not know it;
-  `Token moved`, giving the token's address as the `Token In` line does; and
   `Moved to`, which reads `The swap step that spends it`. A token the decoder
   does not know gives the `Moved from the sender` line alone. A step may also
   take from the user's wallet what the decoder did not read: a V4 step whose
@@ -3327,26 +3296,11 @@ Currently supported:
   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`
+  token, and its spender is the router. These lines change neither the `Paid to`
-  grants, one for each token it names, all for its one spender, gives the same
+  lines nor the minimum's label. A step goes unread when its recipient does not
-  three lines, in step order with those of each `PERMIT2_PERMIT`. A
+  decode as an address, when it is a V3 swap step whose path is shorter than one
-  `PERMIT2_PERMIT` or `PERMIT2_PERMIT_BATCH` whose input the decoder cannot
+  token address or has bytes after its last hop, or when it is a command the
-  read, such as one whose token or spender word has a nonzero top byte, may let
+  decoder does not read: every command other than `PERMIT2_PERMIT`,
-  any spender take any amount of any token: it gives one `Permit2 allowance`
-  line alone, reading `Unknown (could not be decoded)`. These lines change no
-  `Paid to` line: a permit or batch pays nobody. But code that a step runs, such
-  as a V4 pool's hook or a token's own code, can call a spender other than the
-  router, which can then take up to its allowance from the user's wallet before
-  the transaction ends. So an allowance to any spender but the router, or a
-  permit or batch the decoder cannot read, makes the minimum read
-  `Min. paid out`, and when its token is `Token In`, or the decoder does not
-  know its token or `Token In`, it leaves no `Amount` line, whose figure might
-  be too low: a permit of 5,000 USDT to another address and then a V3 exact-in
-  of 600 USDT read with no `Amount` line, and the 600 USDT gets lines of its
-  own. 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`,

src/popup/index.js

@@ -5,13 +5,13 @@ const {
     state,
     saveState,
     onSaveFailure,
-    takeStoredNetwork,
     loadState,
 } = require("../shared/state");
 const { StateUnusableError } = require("../shared/stateSchema");
 const { log, setRuntimeDebug } = require("../shared/log");
 const { refreshPrices } = require("../shared/prices");
 const { refreshBalances } = require("../shared/balances");
+const { copyChainSwitchFields } = require("../shared/chainSwitchFields");
 const { clearPopupCaches } = require("../shared/chainSwitch");
 const {
     $,
@@ -234,7 +234,7 @@ async function followNetworkSwitch() {
     await saveState((stored) => {
         if (stored.networkId === state.networkId) return false;
         settings.cutViewStack();
-        takeStoredNetwork(stored);
+        copyChainSwitchFields(state, stored);
         clearPopupCaches();
         switched = true;
     }).catch(() => {});

src/shared/balances.js

@@ -1,5 +1,4 @@
-// Balance fetching: ETH balances and the balances of the tokens the user
+// Balance fetching: ETH balances via RPC, ERC-20 token balances via
-// tracks via RPC, the other ERC-20 token balances and the holder counts via
 // Blockscout, ENS reverse lookup via RPC.
 
 const {
@@ -82,9 +81,7 @@ function rawUnits(value) {
 // Fetch token balances for a single address from Blockscout.
 // Returns [{ address, name, symbol, decimals, balance, holders }].
 // Filters out spam: only shows tokens that are in the known token list,
-// explicitly tracked by the user, or have >= 1000 holders. A tracked token's
+// explicitly tracked by the user, or have >= 1000 holders.
-// balance is read through the RPC endpoint instead, and its row here gives that
-// entry its holder count and `decimals` (fetchTrackedTokenBalances()).
 //
 // `decimals` and `balance` are each null when the answer is unknown, the same
 // way `holders` already is. Absence is never filled in here: this is the
@@ -208,96 +205,8 @@ async function fetchTokenBalances(
     }
 }
 
-// The entries at `address` of the tokens the user tracks, shaped as
-// fetchTokenBalances() returns them, for the tokens the address holds.
-//
-// The balance is read with balanceOf through the RPC endpoint. The name and
-// symbol are the tracked token's. `decimals` and `holders` are those of
-// Blockscout's entry for the token in `explorerRequest`, this refresh's
-// fetchTokenBalances() for the address; while Blockscout fails they are kept
-// from the token's entry in `previous`, the address's entries before this
-// refresh. The balance is stated at the scale the screens read the token at
-// (resolveTokenDecimals()): the bundled list's, then the one the tracked token
-// records, then Blockscout's, as in fetchTokenBalances().
-//
-// A token whose balanceOf fails keeps its entry in `previous`, as a failed ETH
-// balance keeps its figure, or takes Blockscout's entry from this refresh when
-// it has none. The failure is logged. A balance of zero gets no entry, as a
-// zero Blockscout reports gets none: the balance lists take a tracked token's
-// zero from the tracked list. A token whose symbol the spoof rule refuses gets
-// no entry either, as in fetchTokenBalances().
-//
-// `signal` is as for fetchTokenBalances().
-async function fetchTrackedTokenBalances(
-    provider,
-    address,
-    trackedTokens,
-    previous,
-    explorerRequest,
-    signal,
-) {
-    const listed = trackedTokens.filter(
-        (token) => !isSpoofedSymbol(token.symbol, token.address),
-    );
-    // Each token's balanceOf answer, or null where it failed.
-    const balances = await Promise.all(
-        listed.map(async (token) => {
-            try {
-                const contract = new Contract(
-                    token.address,
-                    ERC20_ABI,
-                    provider,
-                );
-                return await contract.balanceOf(address);
-            } catch (e) {
-                if (!signal?.aborted) {
-                    log.errorf(
-                        "token balance failed",
-                        address,
-                        token.address,
-                        e.shortMessage || e.message,
-                    );
-                }
-                return null;
-            }
-        }),
-    );
-    const explorerRows = await explorerRequest;
-    const reported = explorerRows ?? previous;
-
-    const rows = [];
-    listed.forEach((token, i) => {
-        const lower = token.address.toLowerCase();
-        const entryIn = (list) =>
-            list.find((row) => String(row.address).toLowerCase() === lower);
-        const raw = balances[i];
-        if (raw === null) {
-            const kept = entryIn(previous) || entryIn(explorerRows || []);
-            if (kept) rows.push(kept);
-            return;
-        }
-        if (raw === 0n) return;
-        const entry = entryIn(reported);
-        const decimals = entry ? entry.decimals : null;
-        const known = resolveTokenDecimals(lower, { trackedTokens });
-        const scale = known !== null ? known : decimals;
-        rows.push({
-            address: token.address,
-            name: token.name || "",
-            symbol: token.symbol || "???",
-            decimals: decimals,
-            // null when nothing knows the scale: a holding whose amount
-            // cannot be stated, never a zero.
-            balance: scale === null ? null : formatTokenBalance(raw, scale),
-            holders: entry ? entry.holders : null,
-        });
-    });
-    return rows;
-}
-
 // Fetch ETH balances, ENS names, and ERC-20 token balances for all addresses.
-// `trackedTokens` are the tokens tracked on the active network. `signal` is as
+// `signal` is as for fetchTokenBalances().
-// for fetchTokenBalances().
 async function refreshBalances(
     wallets,
     rpcUrl,
@@ -308,8 +217,6 @@ async function refreshBalances(
 ) {
     log.debugf("refreshBalances start, rpc:", urlOrigin(rpcUrl));
     const provider = getProvider(rpcUrl, networkId);
-    const tracked = trackedTokens || [];
-    const trackedSet = new Set(tracked.map((t) => t.address.toLowerCase()));
     const updates = [];
 
     for (const wallet of wallets) {
@@ -359,42 +266,23 @@ async function refreshBalances(
                     }),
             );
 
-            // ERC-20 token balances: the tracked tokens' through the RPC
+            // ERC-20 token balances via Blockscout
-            // endpoint, and from Blockscout the tokens the user has not
-            // tracked. When Blockscout fails, the untracked rows from before
-            // this refresh stay. The Blockscout request is started first and
-            // handed to fetchTrackedTokenBalances() too, which waits for it
-            // after sending its balanceOf reads, so the two run side by side.
-            const previous = addr.tokenBalances || [];
-            const explorerRequest = fetchTokenBalances(
-                addr.address,
-                blockscoutUrl,
-                tracked,
-                signal,
-            );
             updates.push(
-                Promise.all([
+                fetchTokenBalances(
-                    fetchTrackedTokenBalances(
+                    addr.address,
-                        provider,
+                    blockscoutUrl,
-                        addr.address,
+                    trackedTokens,
-                        tracked,
+                    signal,
-                        previous,
+                ).then((balances) => {
-                        explorerRequest,
+                    if (balances !== null) {
-                        signal,
+                        addr.tokenBalances = balances;
-                    ),
+                        log.debugf(
-                    explorerRequest,
+                            "Token balances",
-                ]).then(([trackedRows, explorerRows]) => {
+                            addr.address,
-                    const untrackedRows = (explorerRows ?? previous).filter(
+                            balances.length,
-                        (row) =>
+                            "tokens",
-                            !trackedSet.has(String(row.address).toLowerCase()),
+                        );
-                    );
+                    }
-                    addr.tokenBalances = trackedRows.concat(untrackedRows);
-                    log.debugf(
-                        "Token balances",
-                        addr.address,
-                        addr.tokenBalances.length,
-                        "tokens",
-                    );
                 }),
             );
         }

src/shared/chainSwitch.js

@@ -6,7 +6,6 @@
 //   applyChainSwitchFields() (chainSwitchFields.js).
 // - followNetworkSwitch() in src/popup/index.js takes a switch the background
 //   or another popup page saved, from the stored record, with
-//   takeStoredNetwork() (state.js), which copies it with
 //   copyChainSwitchFields() (chainSwitchFields.js).
 //
 // Both change `state` inside a save, holding the lock, and both reset the

src/shared/chainSwitchFields.js

@@ -78,9 +78,8 @@ function applyChainSwitchFields(s, newNetworkId) {
 
 // Give `s` every field applyChainSwitchFields() sets, as `switched` holds it:
 // the popup takes a switch the background saved from the stored record this
-// way, rather than performing it again (takeStoredNetwork() in
+// way, rather than performing it again (src/popup/index.js). Balances are
-// src/shared/state.js). Balances are taken by address, and an address
+// taken by address, and an address `switched` does not have keeps none.
-// `switched` does not have keeps none.
 function copyChainSwitchFields(s, switched) {
     s.networkEndpoints = switched.networkEndpoints;
     s.networkTrackedTokens = switched.networkTrackedTokens;

src/shared/state.js

@@ -23,7 +23,6 @@
 // guarantee.
 
 const { networkById } = require("./networks");
-const { copyChainSwitchFields } = require("./chainSwitchFields");
 const {
     DEFAULT_STATE,
     PERSISTED_FIELDS,
@@ -126,10 +125,8 @@ function currentNetwork() {
 }
 
 // The persisted fields as this page held them when its last loadState()
-// finished, or when its last successful saveState() began, with any network
+// finished, or when its last successful saveState() began. saveState() diffs
-// switch saved elsewhere that this page has taken since (takeStoredNetwork()).
+// the live state against this to find only the fields THIS page changed since.
-// saveState() diffs the live state against this to find only the fields THIS
-// page changed since.
 //
 // Deep-cloned, not a reference: callers mutate persisted objects and arrays
 // in place (state.wallets.push(...)), and a reference baseline would mutate
@@ -602,17 +599,6 @@ function saveState(beforeWrite) {
     return turn;
 }
 
-// Give this page the network switch held by `stored`, a record a save of this
-// page has just read (followNetworkSwitch() in src/popup/index.js calls this
-// from `beforeWrite`), in `state` and in `baseline` alike, as loadState() does
-// with a whole record. The switch is then not this page's own change, even when
-// that save fails to write: a later switch back to the previous network still
-// differs from `baseline`, and is stored.
-function takeStoredNetwork(stored) {
-    copyChainSwitchFields(rawState, stored);
-    copyChainSwitchFields(baseline, structuredClone(stored));
-}
-
 // Rejects with StateUnusableError for a stored record this build cannot make
 // sense of. Nothing is assigned and `loaded` stays false in that case, so a
 // caller that ignores the rejection gets StateNotLoadedError on the first
@@ -658,7 +644,6 @@ module.exports = {
     state,
     saveState,
     onSaveFailure,
-    takeStoredNetwork,
     loadState,
     currentAddress,
     currentNetwork,

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
+// takes from the sender, when this decoder does not know it.
-// permit it could not read allows.
 const UNDECODED_CURRENCY = "Unknown (could not be decoded)";
 
 // The Paid to line for each token paid to the router, the swap's output or
@@ -529,32 +528,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:
@@ -953,9 +926,7 @@ function totalAmount(amounts) {
 // 2. Amount is the amountIn of the swap action that spends Token In. If
 //    several exact-in actions spend it, each with a stated amount, it is
 //    their sum; in any other case there is none. Min. received is the same
-//    for amountOutMin and the actions that buy Token Out, except that there
+//    for amountOutMin and the actions that buy Token Out.
-//    is none when a swap action in the step also spends Token Out: the step
-//    then does not pay out all that those actions buy.
 // 3. If any swap action in the step cannot be read, only SETTLE, SETTLE_ALL,
 //    TAKE and TAKE_ALL name the sides, and there is no Amount or Min.
 //    received.
@@ -1189,13 +1160,11 @@ function decodeV4Swap(input) {
         const boughtOnly = currenciesNotIn(bought, spent);
         if (present(takeToken) || boughtOnly.length === 1) {
             tokenOut = present(takeToken) ? takeToken : boughtOnly[0];
-            if (!spent.includes(tokenOut)) {
+            amountOutMin = totalAmount(
-                amountOutMin = totalAmount(
+                swaps
-                    swaps
+                    .filter((s) => s.tokenOut === tokenOut)
-                        .filter((s) => s.tokenOut === tokenOut)
+                    .map((s) => s.amountOutMin),
-                        .map((s) => s.amountOutMin),
+            );
-                );
-            }
         }
 
         return {
@@ -1238,21 +1207,17 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         let inputToken = null;
         let inputAmount = null;
         let inputEstablished = false;
-        // Whether the user pays the step that set the input side: a V2 or V3
+        // Whether the user pays the V4 step that set the input side any of
-        // swap step with `payerIsUser` true, a V4 step the user pays some of
+        // its input currency (see decodeV4Swap()). Only a V4 step can set the
-        // its input currency (see decodeV4Swap()), or a WRAP_ETH, whose ETH
+        // input side with no amount, the one case in which this is read.
-        // comes from the transaction's value. A step paid from the router
-        // takes nothing from the sender.
         let inputPaidByUser = false;
         // The last PERMIT2_PERMIT this decoder read before a step set the
         // input side, or null (see permitStands after the loop).
         let permit = null;
-        // Every allowance a PERMIT2_PERMIT or PERMIT2_PERMIT_BATCH grants,
+        // Every PERMIT2_PERMIT this decoder read, before a step set the input
-        // before a step set the input side or after, in step order, as
+        // side or after, in step order, as { token, amount, spender, step }.
-        // { token, amount, spender, step }. A permit or batch whose input
+        // Each whose amount is not the Amount figure gets lines of its own
-        // this decoder cannot read is one with a null token, amount and
+        // (see after the PERMIT2_TRANSFER_FROM lines).
-        // 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
@@ -1357,15 +1322,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, there is no Amount line, whose figure may
-        // then be too low, and the minimum reads Min. paid out (see
-        // toAnotherSpender).
-        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
@@ -1521,7 +1477,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         permits.push({ ...p, step: i });
                         keepsRouterWeth = true;
                     } else {
-                        permitUnread(i);
+                        stepsUnread.push(i);
                     }
                     // Only a permit whose amount stands as the Amount figure
                     // names Token In (see permitStands). Every other permit,
@@ -1531,16 +1487,14 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     // 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`, `movedIntoRouter` or
+                        // have: one in `userPaid`, when its token is the
-                        // `movedFromSender`, when its token is the permit's
+                        // permit's or not known. No step has set the input
-                        // or not known. No step has set the input side yet.
+                        // side yet.
                         const mayBeItsToken = (token) =>
                             !present(token) || sameAddress(token, p.token);
-                        const tookBefore = [
+                        const tookBefore = userPaid.some((t) =>
-                            ...userPaid,
+                            mayBeItsToken(t.token),
-                            ...movedIntoRouter,
+                        );
-                            ...movedFromSender,
-                        ].some((t) => mayBeItsToken(t.token));
                         permit = {
                             ...p,
                             step: i,
@@ -1548,15 +1502,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                             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);
-                    }
                 } else if (command === "PERMIT2_TRANSFER_FROM") {
                     const p = decodePermit2TransferFrom(inputs[i]);
                     if (!p) {
@@ -1629,7 +1574,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     if (s) {
                         if (!inputEstablished) {
                             setInputOnce(s.tokenIn, s.amountIn);
-                            inputPaidByUser = s.payerIsUser;
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountIn);
                         }
@@ -1653,7 +1597,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     if (s) {
                         if (!inputEstablished) {
                             setInputOnce(s.tokenIn, s.amountIn);
-                            inputPaidByUser = s.payerIsUser;
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountIn);
                         }
@@ -1685,7 +1628,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     if (s) {
                         if (!inputEstablished) {
                             setInputOnce(s.tokenIn, s.amountInMax);
-                            inputPaidByUser = s.payerIsUser;
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountInMax);
                         }
@@ -1781,13 +1723,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 } else if (command === "WRAP_ETH") {
                     const w = decodeWrapEth(inputs[i]);
                     if (w) {
-                        if (!inputEstablished) {
+                        setInputOnce(
-                            setInputOnce(
+                            "0x0000000000000000000000000000000000000000",
-                                "0x0000000000000000000000000000000000000000",
+                            w.amount,
-                                w.amount,
+                        );
-                            );
-                            inputPaidByUser = true;
-                        }
                         addPayee(w.recipient);
                         // CONTRACT_BALANCE wraps all the router's ETH.
                         if (w.amount === CONTRACT_BALANCE) {
@@ -1971,8 +1910,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
+                    // read: PERMIT2_PERMIT_BATCH and the NFT commands among
-                    // release names no command for.
+                    // them, and a type the release names no command for.
                     payeeUnread = true;
                     stepsUnread.push(i);
                 }
@@ -2022,22 +1961,17 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // 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
+        // transaction, its spender is the router, the router may not let it
-        // the router, the router may not let it fail, no step before it took
+        // fail, no step before it took its token or one not known, and this
-        // its token or one not known (a PERMIT2_TRANSFER_FROM of its token
+        // decoder read every step after it in full (see stepsUnread). Permit2
-        // included), and this decoder read every step after it in full (see
+        // then lets the router take no more of the token than that amount, so
-        // stepsUnread). Permit2 then lets the router take no more of the token
+        // the permit covers every take of it. A later step this decoder did
-        // than that amount, so the permit covers every take of it. A step
+        // not read may raise what Permit2 lets the router take, as a
-        // before it takes under whatever allowance the router already had, so
+        // PERMIT2_PERMIT_BATCH can. Every other PERMIT2_PERMIT leaves Token In
-        // it may take more. A later permit or batch, or a later step this
+        // and the Amount line as they read with no permit, and gets lines of
-        // decoder did not read, may raise what Permit2 lets the router take.
+        // its own below. A step that may take from the sender what this decoder
-        // Every other PERMIT2_PERMIT leaves Token In and the Amount line as
+        // did not read leaves no figure, permit or not (see spentUnread()),
-        // they read with no permit, and gets lines of its own below. A step
+        // and an EXECUTE_SUB_PLAN step leaves both sides unknown (below).
-        // that may take from the sender what this decoder did not read leaves
-        // no figure, permit or not (see spentUnread()), and so do a permit
-        // or batch whose input it cannot read (see permitUnread()) and an
-        // allowance of Token In to another spender (see toAnotherSpender). An
-        // EXECUTE_SUB_PLAN step leaves both sides unknown (below).
         const stepCommands = Array.from(
             commandsBytes,
             (b) => commands[b & commandTypeMask],
@@ -2045,7 +1979,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 &&
@@ -2055,11 +1988,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // (see spentUnread()), or a token it does not know.
         const spentFromSender = [];
         let total = null;
-        // The takes from the sender that `total` adds up, each a quantity, as
-        // { token, amount }. When there is no Amount line, each gets lines of
-        // its own (see below). The amount of a step that set the input side
-        // and is paid from the router counts in `total` but is not among them.
-        const inTotal = [];
         // Whether the step that set the input side counts as a take from the
         // sender, which may get lines of its own. The amount it stated counts
         // whoever pays it. Stating none, it counts only when the user pays it
@@ -2072,9 +2000,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         let firstTakeUnstated = null;
         if (!permitStands || sameAddress(inputToken, permit.token)) {
             total = inputAmount;
-            if (typeof inputAmount === "bigint" && inputPaidByUser) {
-                inTotal.push({ token: inputToken, amount: inputAmount });
-            }
             if (hasFirstTake && !present(inputAmount)) {
                 firstTakeUnstated = { token: inputToken, amount: null };
             }
@@ -2093,7 +2018,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 typeof t.amount === "bigint"
             ) {
                 total += t.amount;
-                inTotal.push(t);
                 continue;
             }
             spentFromSender.push(t);
@@ -2222,30 +2146,12 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             return amountText(amount, info);
         };
 
-        // Each allowance to a spender other than the router. Code that a step
-        // runs, such as a V4 pool's hook or a token's own code, can call that
-        // spender, which can then take up to the allowance from the sender
-        // before the transaction ends. A permit or batch this decoder could
-        // not read may be to any spender, of any token.
-        const toAnotherSpender = permits.filter(
-            (p) => !sameAddress(p.spender, toAddress),
-        );
-
         // A null token in `spentFromSender`, a step this decoder did not read
-        // or a token it does not know, and an allowance to another spender
+        // or a token it does not know, leaves no Amount figure, which may
-        // that may be of Token In, leave no Amount figure, which may then be
+        // then be too low.
-        // too low. With no Amount line, each take the total adds up gets
-        // lines of its own, first, so that every amount this decoder read is
-        // shown.
         if (
             present(inputAmount) &&
-            spentFromSender.every((s) => present(s.token)) &&
+            spentFromSender.every((s) => present(s.token))
-            toAnotherSpender.every(
-                (p) =>
-                    present(p.token) &&
-                    present(inputToken) &&
-                    !sameAddress(p.token, inputToken),
-            )
         ) {
             const amount = spentText(inputAmount, inInfo);
             details.push({
@@ -2253,8 +2159,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 value: amount.display,
                 rawValue: amount.raw,
             });
-        } else {
-            spentFromSender.unshift(...inTotal);
         }
 
         // What steps take from the sender beyond the Amount line, in the shape
@@ -2297,24 +2201,16 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             );
         }
 
-        // What each allowance of a PERMIT2_PERMIT or PERMIT2_PERMIT_BATCH lets
+        // What each PERMIT2_PERMIT lets its spender take: its amount, its
-        // its spender take: its amount, its token and the spender, an address
+        // token and the spender, an address on a line of its own. Permit2's
-        // on a line of its own. Permit2's maximum is unbounded. Only a permit
+        // maximum is unbounded. Only a permit whose amount stands as the
-        // whose amount stands as the Amount figure (see permitStands) gets
+        // Amount figure (see permitStands) gets none: that line already gives
-        // none: that line already gives its amount and Token In its token,
+        // its amount and Token In its token, and its spender is the router.
-        // and its spender is the router. Every other allowance, one after the
+        // Every other permit, one after the step that set the input side
-        // step that set the input side included, gets these lines, so nothing
+        // included, gets these lines, so nothing it lets anyone take goes
-        // it lets anyone take goes unstated. A permit or batch this decoder
+        // unstated.
-        // 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:
@@ -2366,10 +2262,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // step pays the bridge, when one moves the sender's tokens into the
         // router, when a token stays in the router, and when a payout could
         // not be read. The output is received by the sender only when some
-        // step pays the sender, there is no such line, and no allowance goes
+        // step pays the sender and there is no such line. When no step names
-        // to another spender (see toAnotherSpender). When no step names anyone
+        // anyone paid, one line says so. `paidTo` holds these lines and the
-        // paid, one line says so. `paidTo` holds these lines and the token
+        // token line after each line about a token in the router.
-        // line after each line about a token in the router.
         const outputHeld =
             present(outputToken) && heldByRouter.has(outputToken.toLowerCase());
         const paidTo = paidElsewhere.map((address) => ({
@@ -2416,10 +2311,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         if (payeeUnread) {
             paidTo.push({ label: "Paid to", value: UNDECODED_CURRENCY });
         }
-        const received =
+        const received = paidToSender && paidTo.length === 0;
-            paidToSender &&
-            paidTo.length === 0 &&
-            toAnotherSpender.length === 0;
         if (!paidToSender && paidTo.length === 0) {
             paidTo.push({ label: "Paid to", value: UNNAMED_CURRENCY });
         }

tests/balanceRefreshCancelled.test.js

@@ -18,11 +18,6 @@ const {
 const RPC_URL = "https://rpc.example.invalid";
 const EXPLORER_URL = "https://explorer.example.invalid/api/v2";
 const ADDRESS = "0x1111111111111111111111111111111111111111";
-const TRACKED = {
-    address: "0x7777777777777777777777777777777777777777",
-    symbol: "TRK",
-    decimals: 6,
-};
 
 const realFetch = globalThis.fetch;
 let logged;
@@ -35,9 +30,9 @@ beforeEach(() => {
     const failedToFetch = async () => {
         throw new TypeError("Failed to fetch");
     };
-    // The RPC calls (ETH balance, ENS name, the tracked token's balance, and
+    // The RPC calls (ETH balance, ENS name, and the scan's balance and
-    // the scan's balance and transaction count) and the explorer request (the
+    // transaction count) and the explorer request (token balances) all fail
-    // other token balances) all fail the same way.
+    // the same way.
     FetchRequest.registerGetUrl(failedToFetch);
     globalThis.fetch = jest.fn(failedToFetch);
 });
@@ -54,7 +49,7 @@ function refresh(signal) {
         wallets,
         RPC_URL,
         EXPLORER_URL,
-        [TRACKED],
+        [],
         "mainnet",
         signal,
     );
@@ -65,7 +60,6 @@ test("a failure while the popup is open is reported", async () => {
     for (const label of [
         "ETH balance failed",
         "ENS reverse failed",
-        "token balance failed",
         "fetchTokenBalances failed: Failed to fetch",
     ]) {
         expect(logged.some((line) => line.includes(label))).toBe(true);

tests/e2e/run.js

@@ -3480,24 +3480,6 @@ function hostileSymbolState(page, tokenAddress) {
 }
 
 test("a token whose symbol() returns markup renders as text (#307)", async (env) => {
-    // The stub token is no longer tracked from here on, so the explorer is
-    // what lists it, as it lists a token airdropped to the victim. A tracked
-    // token is listed from the RPC endpoint under the symbol it was added
-    // with, which the hostile symbol below never reaches
-    // (https://git.eeqj.de/sneak/AutistMask/issues/669).
-    await env.page.click("#btn-settings");
-    await visible(env.page, "#view-settings");
-    await env.page.click("#settings-tracked-tokens .btn-remove-token");
-    // The list is drawn again once the removal is saved.
-    await env.page.waitForFunction(
-        () =>
-            document
-                .getElementById("settings-tracked-tokens")
-                .innerText.trim() === "None",
-    );
-    await env.page.click("#btn-settings-back");
-    await visible(env.page, "#view-address");
-
     env.routeOpts.ethBalanceWei = toHexWei(FUNDED_ETH_WEI);
     env.routeOpts.seedTokenBalance = true;
     env.routeOpts.tokenSymbolOverride = HOSTILE_SYMBOL;

tests/popupFollowsNetworkSwitch.test.js

@@ -220,39 +220,6 @@ test("a switch in Settings made while a follow waits for the lock is not overwri
     expect(told.at(-1).chainId).toBe(NETWORKS.mainnet.chainId);
 });
 
-// The popup follows the background's switch to Sepolia, but its own write in
-// that save fails. The user then picks Ethereum Mainnet in Settings, the
-// network the popup was on before: that switch is stored, and only then
-// flashed and sent to sites.
-test("a switch back in Settings after a follow whose write failed is stored", async () => {
-    const page = await bootOnAddress();
-    await page.click("btn-settings");
-    const { set } = page.storage.local;
-    const write = set.getMockImplementation();
-    // The background's write lands; the next, the follow's, fails.
-    set.mockImplementationOnce(write).mockRejectedValueOnce(
-        new Error("quota exceeded"),
-    );
-    await backgroundSwitch(page, "sepolia");
-    const { state } = require("../src/shared/state");
-    expect(state.networkId).toBe("sepolia");
-
-    const select = page.node("settings-network");
-    select.value = "mainnet";
-    for (const fn of select.listeners.change) await fn();
-    await page.settle();
-
-    const stored = page.storage.read("autistmask");
-    expect(stored.networkId).toBe("mainnet");
-    expect(stored.rpcUrl).toBe(NETWORKS.mainnet.defaultRpcUrl);
-    expect(stored.trackedTokens).toEqual([MAINNET_TOKEN]);
-    expect(page.text("flash-msg")).toBe("Switched to Ethereum Mainnet.");
-    const told = globalThis.chrome.runtime.sendMessage.mock.calls
-        .map(([message]) => message)
-        .filter((message) => message.type === "AUTISTMASK_NETWORK_CHANGED");
-    expect(told.at(-1).chainId).toBe(NETWORKS.mainnet.chainId);
-});
-
 // Such as one a newer build wrote, which this build cannot read. Nothing reads
 // or writes the stored record for it: the popup's next save finds it, as
 // before.

tests/trackedTokenBalances.test.js

@@ -1,303 +0,0 @@
-// The balance of each token the user tracks is read with balanceOf through the
-// RPC endpoint, for every address. Blockscout's answer gives a tracked token its
-// holder count and decimals, and adds the tokens the user has not tracked
-// (https://git.eeqj.de/sneak/AutistMask/issues/669).
-//
-// The real refreshBalances() runs against a fake JSON-RPC node, answered
-// through ethers' own request hook, and a fake Blockscout, answered through
-// fetch().
-
-const { AbiCoder, FetchRequest } = require("ethers");
-const { refreshBalances } = require("../src/shared/balances");
-
-const RPC_URL = "https://rpc.example.invalid";
-const EXPLORER_URL = "https://explorer.example.invalid/api/v2";
-const FIRST = "0x1111111111111111111111111111111111111111";
-const SECOND = "0x2222222222222222222222222222222222222222";
-
-// A token the user tracks, outside the bundled list, at 6 decimals.
-const TOKEN = "0x7777777777777777777777777777777777777777";
-const TRACKED = {
-    address: TOKEN,
-    symbol: "TRK",
-    name: "Tracked Token",
-    decimals: 6,
-};
-
-// USDC, from the bundled list, which the user does not track.
-const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
-// Neither on the bundled list nor tracked.
-const OTHER = "0x8888888888888888888888888888888888888888";
-
-const ZERO_WORD = "0x" + "0".repeat(64);
-const BALANCE_OF = "0x70a08231";
-
-// What balanceOf answers, by token contract and then by holder. A pair that is
-// not here makes balanceOf fail.
-let holdings;
-// What Blockscout answers for every address; null makes the request fail.
-let explorerRows;
-let logged;
-
-// One JSON-RPC answer. A call that is not balanceOf is the ENS reverse lookup,
-// answered with no resolver, so no name.
-function reply(req) {
-    const envelope = { jsonrpc: "2.0", id: req.id };
-    if (req.method === "eth_getBalance") {
-        return { ...envelope, result: "0x0" };
-    }
-    if (req.method !== "eth_call") {
-        return {
-            ...envelope,
-            error: { code: -32601, message: "method not found" },
-        };
-    }
-    const { to, data } = req.params[0];
-    if (!data.startsWith(BALANCE_OF)) return { ...envelope, result: ZERO_WORD };
-    const holder = "0x" + data.slice(-40);
-    const amount = (holdings[to.toLowerCase()] || {})[holder];
-    if (amount === undefined) {
-        return {
-            ...envelope,
-            error: { code: -32000, message: "fixture: balanceOf failed" },
-        };
-    }
-    return {
-        ...envelope,
-        result: AbiCoder.defaultAbiCoder().encode(["uint256"], [amount]),
-    };
-}
-
-const realFetch = globalThis.fetch;
-
-beforeEach(() => {
-    holdings = {};
-    explorerRows = null;
-    logged = [];
-    jest.spyOn(console, "error").mockImplementation((...args) => {
-        logged.push(args.map(String).join(" "));
-    });
-    FetchRequest.registerGetUrl(async (req) => {
-        const body = JSON.parse(Buffer.from(req.body).toString("utf8"));
-        const answer = Array.isArray(body) ? body.map(reply) : reply(body);
-        return {
-            statusCode: 200,
-            statusMessage: "OK",
-            headers: { "content-type": "application/json" },
-            body: Buffer.from(JSON.stringify(answer)),
-        };
-    });
-    globalThis.fetch = jest.fn(async () => {
-        if (explorerRows === null) throw new TypeError("Failed to fetch");
-        return { ok: true, status: 200, json: async () => explorerRows };
-    });
-});
-
-afterEach(() => {
-    FetchRequest.registerGetUrl(FetchRequest.createGetUrlFunc());
-    globalThis.fetch = realFetch;
-    jest.restoreAllMocks();
-});
-
-// One Blockscout token-balances row.
-function explorerRow(address, symbol, value, holders = "50000") {
-    return {
-        value: String(value),
-        token: {
-            type: "ERC-20",
-            address_hash: address,
-            symbol: symbol,
-            name: symbol,
-            decimals: "6",
-            holders_count: holders,
-        },
-    };
-}
-
-// The row refreshBalances() writes for TOKEN from a balanceOf answer, with the
-// decimals and holder count Blockscout reported for it, if any.
-function trackedRow(balance, decimals = null, holders = null) {
-    return {
-        address: TOKEN,
-        name: "Tracked Token",
-        symbol: "TRK",
-        decimals: decimals,
-        balance: balance,
-        holders: holders,
-    };
-}
-
-async function refresh(addresses, trackedTokens) {
-    await refreshBalances(
-        [{ addresses }],
-        RPC_URL,
-        EXPLORER_URL,
-        trackedTokens,
-        "mainnet",
-        new AbortController().signal,
-    );
-    return addresses;
-}
-
-test("with Blockscout failing, a tracked token's balance is read through the RPC endpoint for every address", async () => {
-    holdings[TOKEN] = { [FIRST]: 1234500000n, [SECOND]: 1n };
-    const [first, second] = await refresh(
-        [
-            { address: FIRST, tokenBalances: [] },
-            { address: SECOND, tokenBalances: [] },
-        ],
-        [TRACKED],
-    );
-    expect(first.tokenBalances).toEqual([trackedRow("1234.5")]);
-    // Exact, never cut: one base unit is not zero.
-    expect(second.tokenBalances).toEqual([trackedRow("0.000001")]);
-});
-
-test("with Blockscout failing, the untracked rows from before stay", async () => {
-    holdings[TOKEN] = { [FIRST]: 2000000n };
-    const usdc = {
-        address: USDC,
-        name: "USD Coin",
-        symbol: "USDC",
-        decimals: 6,
-        balance: "5.0",
-        holders: 50000,
-    };
-    const [first] = await refresh(
-        [{ address: FIRST, tokenBalances: [usdc] }],
-        [TRACKED],
-    );
-    expect(first.tokenBalances).toEqual([trackedRow("2.0"), usdc]);
-});
-
-test("a tracked token Blockscout also reports shows the RPC figure, and an untracked one is admitted as before", async () => {
-    holdings[TOKEN] = { [FIRST]: 2000000n };
-    explorerRows = [
-        explorerRow(TOKEN, "TRK", 9000000),
-        explorerRow(USDC, "USDC", 5000000),
-        // Too few holders, and neither on the bundled list nor tracked.
-        explorerRow(OTHER, "SPAM", 5000000, "10"),
-        // A known symbol from a contract it does not belong to.
-        explorerRow(OTHER, "USDC", 5000000),
-    ];
-    const [first] = await refresh(
-        [{ address: FIRST, tokenBalances: [] }],
-        [TRACKED],
-    );
-    expect(first.tokenBalances).toEqual([
-        trackedRow("2.0", 6, 50000),
-        {
-            address: USDC,
-            name: "USDC",
-            symbol: "USDC",
-            decimals: 6,
-            balance: "5.0",
-            holders: 50000,
-        },
-    ]);
-});
-
-test("a tracked token's entry carries the holder count and decimals Blockscout reports for it", async () => {
-    holdings[TOKEN] = { [FIRST]: 2000000n };
-    // Fewer holders than "Hide tokens with fewer than 1,000 holders" lets
-    // through to Send's token list.
-    explorerRows = [explorerRow(TOKEN, "TRK", 9000000, "10")];
-    const [first] = await refresh(
-        [{ address: FIRST, tokenBalances: [] }],
-        [TRACKED],
-    );
-    expect(first.tokenBalances).toEqual([trackedRow("2.0", 6, 10)]);
-});
-
-test("while Blockscout fails, a tracked token keeps the holder count and decimals of its entry from before", async () => {
-    holdings[TOKEN] = { [FIRST]: 2000000n };
-    const [first] = await refresh(
-        [{ address: FIRST, tokenBalances: [trackedRow("7.0", 6, 10)] }],
-        [TRACKED],
-    );
-    expect(first.tokenBalances).toEqual([trackedRow("2.0", 6, 10)]);
-});
-
-test("a failed balanceOf keeps the token's entry from before, and is logged", async () => {
-    explorerRows = [explorerRow(TOKEN, "TRK", 9000000)];
-    const before = trackedRow("7.0", 6, 50000);
-    const [first] = await refresh(
-        [{ address: FIRST, tokenBalances: [before] }],
-        [TRACKED],
-    );
-    expect(first.tokenBalances).toEqual([before]);
-    expect(logged.some((line) => line.includes("token balance failed"))).toBe(
-        true,
-    );
-});
-
-test("a failed balanceOf with no entry from before takes Blockscout's entry from this refresh", async () => {
-    // balanceOf fails at FIRST and answers at SECOND.
-    holdings[TOKEN] = { [SECOND]: 2000000n };
-    explorerRows = [explorerRow(TOKEN, "TRK", 9000000)];
-    const [first, second] = await refresh(
-        [
-            { address: FIRST, tokenBalances: [] },
-            { address: SECOND, tokenBalances: [] },
-        ],
-        [TRACKED],
-    );
-    expect(first.tokenBalances).toEqual([
-        {
-            address: TOKEN,
-            name: "TRK",
-            symbol: "TRK",
-            decimals: 6,
-            balance: "9.0",
-            holders: 50000,
-        },
-    ]);
-    // Where balanceOf answers, its figure stands.
-    expect(second.tokenBalances).toEqual([trackedRow("2.0", 6, 50000)]);
-});
-
-test("a balance of zero read through the RPC endpoint replaces the previous figure", async () => {
-    holdings[TOKEN] = { [FIRST]: 0n };
-    const [first] = await refresh(
-        [{ address: FIRST, tokenBalances: [trackedRow("7.0")] }],
-        [TRACKED],
-    );
-    expect(first.tokenBalances).toEqual([]);
-});
-
-test("a tracked token whose scale nothing knows gets no quantity, not a zero", async () => {
-    holdings[TOKEN] = { [FIRST]: 5n };
-    const [first] = await refresh(
-        [{ address: FIRST, tokenBalances: [] }],
-        [{ ...TRACKED, decimals: null }],
-    );
-    expect(first.tokenBalances).toEqual([trackedRow(null)]);
-});
-
-test("a tracked token whose scale only Blockscout reports is stated at that scale", async () => {
-    holdings[TOKEN] = { [FIRST]: 2000000n };
-    explorerRows = [explorerRow(TOKEN, "TRK", 9000000)];
-    const [first] = await refresh(
-        [{ address: FIRST, tokenBalances: [] }],
-        [{ ...TRACKED, decimals: null }],
-    );
-    expect(first.tokenBalances).toEqual([trackedRow("2.0", 6, 50000)]);
-});
-
-test("a tracked token wearing a known symbol from another contract is not listed", async () => {
-    holdings[OTHER] = { [FIRST]: 5000000n };
-    // Its entry from before goes too, although Blockscout fails.
-    const before = {
-        address: OTHER,
-        name: "Fake",
-        symbol: "USDC",
-        decimals: 6,
-        balance: "5.0",
-        holders: 50000,
-    };
-    const [first] = await refresh(
-        [{ address: FIRST, tokenBalances: [before] }],
-        [{ address: OTHER, symbol: "USDC", name: "Fake", decimals: 6 }],
-    );
-    expect(first.tokenBalances).toEqual([]);
-});

tests/uniswap.test.js

@@ -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(
@@ -1447,20 +1428,6 @@ describe("uniswap decoder", () => {
             USDT_ADDR,
             USDC_ADDR,
         ]);
-        // The lines of its 600 USDT when there is no Amount line.
-        // https://git.eeqj.de/sneak/AutistMask/issues/659 — on next at
-        // 5f2b606 no line gave the 600 USDT then.
-        const USDT_600_GROUP = [
-            ["Moved from the sender", "600.0000 USDT"],
-            ["Token moved", "USDT (" + USDT_ADDR + ")"],
-            ["Moved to", "The swap step that spends it"],
-        ];
-        // The same for a step's 400 USDT.
-        const USDT_400_GROUP = [
-            ["Moved from the sender", "400.0000 USDT"],
-            ["Token moved", "USDT (" + USDT_ADDR + ")"],
-            ["Moved to", "The swap step that spends it"],
-        ];
         // V4 SETTLE of `amount` of `currency`, and TAKE of `amount` of
         // `currency` to `recipient`.
         const settle = (currency, amount, payerIsUser) =>
@@ -1687,7 +1654,6 @@ describe("uniswap decoder", () => {
                     encodeV4SettleAll(USDT_ADDR, USDT_400),
                 ],
                 lines: [
-                    ...USDT_600_GROUP,
                     ["Moved from the sender", UNDECODED],
                     ["Token moved", "USDT (" + USDT_ADDR + ")"],
                     ["Moved to", "The swap step that spends it"],
@@ -1708,7 +1674,6 @@ describe("uniswap decoder", () => {
                     encodeV4TakeAll(USDC_ADDR, 0n),
                 ],
                 lines: [
-                    ...USDT_600_GROUP,
                     ["Moved from the sender", UNDECODED],
                     ["Token moved", "USDT (" + USDT_ADDR + ")"],
                     ["Moved to", "The swap step that spends it"],
@@ -1840,8 +1805,6 @@ describe("uniswap decoder", () => {
 
         // A step that may take from the sender what the decoder did not read
         // leaves no Amount figure, which may be too low, and one line says so.
-        // The amount of the step that set the input side then gets lines of
-        // its own.
         const UNREAD_SWAP = V4_SWAP_ACTION_SHAPES[0].newer;
         test.each([
             {
@@ -1889,7 +1852,6 @@ describe("uniswap decoder", () => {
                 [V3_600, encodeV4Swap(new Uint8Array(actions), params)],
             );
             expect(linesBetweenTokens(result)).toEqual([
-                ...USDT_600_GROUP,
                 ["Moved from the sender", UNDECODED],
             ]);
         });
@@ -1912,9 +1874,6 @@ describe("uniswap decoder", () => {
                         ],
                     ),
                 ],
-                // Nothing read says the user pays this step, so its 400 USDT
-                // gets no lines of its own.
-                first: [],
             },
             {
                 kind: "a V3 step of 600 USDT, then a V4 step whose input cannot be read",
@@ -1985,27 +1944,9 @@ describe("uniswap decoder", () => {
                     ),
                 ],
             },
-            // Each take the total would add up gets lines of its own.
+        ])("$kind", ({ commands, inputs }) => {
-            {
-                kind: "a V3 step of 600 USDT and a V2 step of 400 USDT the user pays for, then a PERMIT2_TRANSFER_FROM_BATCH",
-                commands: [0x00, 0x08, 0x0d],
-                inputs: [
-                    V3_600,
-                    encodeV2SwapExactIn(USER_ADDR, USDT_400, 390000000n, [
-                        USDT_ADDR,
-                        USDC_ADDR,
-                    ]),
-                    coder.encode(
-                        ["tuple(address,address,uint160,address)[]"],
-                        [[[USER_ADDR, OTHER_ADDR, USDT_400, USDT_ADDR]]],
-                    ),
-                ],
-                first: [...USDT_600_GROUP, ...USDT_400_GROUP],
-            },
-        ])("$kind", ({ commands, inputs, first = USDT_600_GROUP }) => {
             const result = decodeSteps(commands, inputs);
             expect(linesBetweenTokens(result)).toEqual([
-                ...first,
                 ["Moved from the sender", UNDECODED],
             ]);
         });
@@ -2024,7 +1965,6 @@ describe("uniswap decoder", () => {
                 commands: [0x00, 0x08, 0x21],
                 inputs: [V3_600, V2_DAI_400, SUB_PLAN],
                 lines: [
-                    ...USDT_600_GROUP,
                     ["Moved from the sender", "400.0000 DAI"],
                     ["Token moved", "DAI (" + DAI_ADDR + ")"],
                     ["Moved to", "The swap step that spends it"],
@@ -2036,7 +1976,6 @@ describe("uniswap decoder", () => {
                 commands: [0x21, 0x00, 0x08],
                 inputs: [SUB_PLAN, V3_600, V2_DAI_400],
                 lines: [
-                    ...USDT_600_GROUP,
                     ["Moved from the sender", UNDECODED],
                     ["Moved from the sender", "400.0000 DAI"],
                     ["Token moved", "DAI (" + DAI_ADDR + ")"],
@@ -2055,7 +1994,6 @@ describe("uniswap decoder", () => {
                     SUB_PLAN,
                 ],
                 lines: [
-                    ...USDT_600_GROUP,
                     ["Moved from the sender", UNDECODED],
                     ["Moved from the sender", "400.0000 DAI"],
                     ["Token moved", "DAI (" + DAI_ADDR + ")"],
@@ -2108,6 +2046,12 @@ describe("uniswap decoder", () => {
         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],
@@ -2156,17 +2100,28 @@ describe("uniswap decoder", () => {
             ROUTER_ADDR,
         );
 
-        // A PERMIT2_PERMIT_BATCH may raise what the router may take of the
+        // A PERMIT2_PERMIT_BATCH, which this decoder does not read, may raise
-        // permit's token again, and its allowance gets lines of its own.
+        // 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(
+                    permitBatch,
-                        [[USDT_ADDR, 10000000000n]], // 10,000 USDT
-                        ROUTER_ADDR,
-                    ),
                     V3_600,
                     encodeV2SwapExactIn(USER_ADDR, 9400000000n, 1n, [
                         USDT_ADDR,
@@ -2177,12 +2132,6 @@ describe("uniswap decoder", () => {
             expect(linesBetweenTokens(result)).toEqual([
                 ["Amount", "10000.0000 USDT"],
                 ...USDT_600_LINES,
-                ...permitLines(
-                    "10000.0000 USDT",
-                    USDT_ADDR,
-                    "USDT",
-                    ROUTER_ADDR,
-                ),
             ]);
         });
 
@@ -2233,197 +2182,6 @@ describe("uniswap decoder", () => {
             },
         );
 
-        // https://git.eeqj.de/sneak/AutistMask/issues/655 — a
-        // PERMIT2_TRANSFER_FROM of the permit's token before the permit moves
-        // it under whatever allowance the router already had, so it may move
-        // more than the permit's amount. The permit's amount then does not
-        // stand, and the Amount line gives the total the steps take, as with
-        // no permit. On next at f53b503 the first two rows read the permit's
-        // 600.0000 USDT as the Amount figure, with no lines for the permit.
-        // One after the permit, as in Uniswap's own V2 routes, moves no more
-        // than the permit's amount, and one of another token before it moves
-        // none of the permit's token, so in the last two rows the permit's
-        // amount stands.
-        const USDT_2000 = 2000000000n;
-        // The V2 pair of WETH and USDC on Ethereum Mainnet.
-        const WETH_USDC_PAIR = "0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc";
-        // A PERMIT2_TRANSFER_FROM of `amount` of `token` to `recipient`.
-        const permit2TransferFrom = (token, recipient, amount) =>
-            coder.encode(
-                ["address", "address", "uint160"],
-                [token, recipient, amount],
-            );
-        test.each([
-            {
-                kind: "a PERMIT2_TRANSFER_FROM of 2,000 USDT into the router, then a PERMIT2_PERMIT of 600 USDT and a V3 exact-in of 2,000 USDT paid from the router, shows the total the steps take and the permit's own lines",
-                commands: [0x02, 0x0a, 0x00],
-                inputs: [
-                    permit2TransferFrom(USDT_ADDR, ROUTER_ADDR, USDT_2000),
-                    encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
-                    coder.encode(
-                        ["address", "uint256", "uint256", "bytes", "bool"],
-                        [
-                            USER_ADDR,
-                            USDT_2000,
-                            1n,
-                            encodeV3Path([USDT_ADDR, USDC_ADDR]),
-                            false,
-                        ],
-                    ),
-                ],
-                lines: [["Amount", "2000.0000 USDT"], ...USDT_600_LINES],
-            },
-            {
-                kind: "a PERMIT2_TRANSFER_FROM of 2,000 USDT to another address, then a PERMIT2_PERMIT of 600 USDT and a V3 exact-in of 600 USDT, shows the total the steps take and the permit's own lines",
-                commands: [0x02, 0x0a, 0x00],
-                inputs: [
-                    permit2TransferFrom(USDT_ADDR, OTHER_ADDR, USDT_2000),
-                    encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
-                    V3_600,
-                ],
-                lines: [
-                    ["Amount", "600.0000 USDT"],
-                    ["Moved from the sender", "2000.0000 USDT"],
-                    ["Token moved", "USDT (" + USDT_ADDR + ")"],
-                    ["Moved to", OTHER_ADDR],
-                    ...USDT_600_LINES,
-                ],
-            },
-            {
-                kind: "a PERMIT2_PERMIT of 1 WETH, then a PERMIT2_TRANSFER_FROM of 1 WETH to the V2 pair and a V2 exact-in of ALREADY_PAID, shows the permit's amount",
-                commands: [0x0a, 0x02, 0x08],
-                inputs: [
-                    encodePermit2(WETH_ADDR, ONE_WETH, ROUTER_ADDR),
-                    permit2TransferFrom(WETH_ADDR, WETH_USDC_PAIR, ONE_WETH),
-                    encodeV2SwapExactIn(USER_ADDR, 0n, 1990000000n, [
-                        WETH_ADDR,
-                        USDC_ADDR,
-                    ]),
-                ],
-                lines: [
-                    ["Amount", "1.0000 WETH"],
-                    ["Moved from the sender", "1.0000 WETH"],
-                    ["Token moved", "WETH (" + WETH_ADDR + ")"],
-                    ["Moved to", "The V2 pair the next swap spends"],
-                ],
-            },
-            {
-                kind: "a PERMIT2_TRANSFER_FROM of 400 DAI to another address, then a PERMIT2_PERMIT of 600 USDT and a V3 exact-in of 600 USDT, shows the permit's amount",
-                commands: [0x02, 0x0a, 0x00],
-                inputs: [
-                    permit2TransferFrom(DAI_ADDR, OTHER_ADDR, DAI_400),
-                    encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
-                    V3_600,
-                ],
-                lines: [
-                    ["Amount", "600.0000 USDT"],
-                    ["Moved from the sender", "400.0000 DAI"],
-                    ["Token moved", "DAI (" + DAI_ADDR + ")"],
-                    ["Moved to", OTHER_ADDR],
-                ],
-            },
-        ])("$kind", ({ commands, inputs, lines }) => {
-            const result = decodeSteps(commands, inputs);
-            expect(linesBetweenTokens(result)).toEqual(lines);
-        });
-
-        // A step that sets the input side and is paid from the router takes
-        // nothing from the sender, so with no Amount line its amount gets no
-        // lines of its own: in each route below the sender's 600 USDT moves
-        // into the router first, and such lines would say it left twice.
-        const INTO_ROUTER_600 = permit2TransferFrom(
-            USDT_ADDR,
-            ROUTER_ADDR,
-            USDT_600,
-        );
-        const V3_600_FROM_ROUTER = coder.encode(
-            ["address", "uint256", "uint256", "bytes", "bool"],
-            [
-                USER_ADDR,
-                USDT_600,
-                590000000n,
-                encodeV3Path([USDT_ADDR, USDC_ADDR]),
-                false,
-            ],
-        );
-        const TRANSFER_FROM_BATCH = coder.encode(
-            ["tuple(address,address,uint160,address)[]"],
-            [[[USER_ADDR, OTHER_ADDR, USDT_400, USDT_ADDR]]],
-        );
-        test.each([
-            {
-                kind: "a PERMIT2_TRANSFER_FROM of 600 USDT into the router, a V3 exact-in of 600 USDT paid from the router, then a PERMIT2_TRANSFER_FROM_BATCH",
-                commands: [0x02, 0x00, 0x0d],
-                inputs: [
-                    INTO_ROUTER_600,
-                    V3_600_FROM_ROUTER,
-                    TRANSFER_FROM_BATCH,
-                ],
-                lines: [["Moved from the sender", UNDECODED]],
-            },
-            {
-                kind: "a PERMIT2_PERMIT that cannot be read, a PERMIT2_TRANSFER_FROM of 600 USDT into the router, then a V3 exact-in of 600 USDT paid from the router",
-                commands: [0x0a, 0x02, 0x00],
-                inputs: [
-                    dirtyWord(
-                        encodePermit2(USDT_ADDR, 5000000000n, ROUTER_ADDR),
-                        0,
-                    ),
-                    INTO_ROUTER_600,
-                    V3_600_FROM_ROUTER,
-                ],
-                lines: [["Permit2 allowance", UNDECODED]],
-            },
-            {
-                kind: "a PERMIT2_TRANSFER_FROM of 600 USDT into the router, a V4 step swapping 600 USDT whose SETTLE the router pays, then a PERMIT2_TRANSFER_FROM_BATCH",
-                commands: [0x02, 0x10, 0x0d],
-                inputs: [
-                    INTO_ROUTER_600,
-                    encodeV4Swap(
-                        new Uint8Array([
-                            V4_SWAP_EXACT_IN_SINGLE_ID,
-                            V4_SETTLE_ID,
-                            V4_TAKE_ALL_ID,
-                        ]),
-                        [
-                            encodeV4ExactInSingle(
-                                USDT_ADDR,
-                                USDC_ADDR,
-                                USDT_600,
-                                590000000n,
-                            ),
-                            settle(USDT_ADDR, USDT_600, false),
-                            encodeV4TakeAll(USDC_ADDR, 0n),
-                        ],
-                    ),
-                    TRANSFER_FROM_BATCH,
-                ],
-                lines: [["Moved from the sender", UNDECODED]],
-            },
-            {
-                kind: "a PERMIT2_TRANSFER_FROM of 600 USDT into the router, a V2 exact-in of CONTRACT_BALANCE paid from the router, then an EXECUTE_SUB_PLAN",
-                commands: [0x02, 0x08, 0x21],
-                inputs: [
-                    INTO_ROUTER_600,
-                    coder.encode(
-                        ["address", "uint256", "uint256", "address[]", "bool"],
-                        [
-                            USER_ADDR,
-                            2n ** 255n, // CONTRACT_BALANCE
-                            590000000n,
-                            [USDT_ADDR, USDC_ADDR],
-                            false,
-                        ],
-                    ),
-                    SUB_PLAN,
-                ],
-                lines: [["Moved from the sender", UNDECODED]],
-            },
-        ])("$kind", ({ commands, inputs, lines }) => {
-            const result = decodeSteps(commands, inputs);
-            expect(linesBetweenTokens(result)).toEqual(lines);
-        });
-
         // A V3_SWAP_EXACT_OUT the user pays for, of at most `amountInMax`
         // USDT for USDC.
         const v3ExactOut = (amountInMax) =>
@@ -2544,6 +2302,20 @@ describe("uniswap decoder", () => {
                     ],
                     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],
@@ -2646,269 +2418,6 @@ describe("uniswap decoder", () => {
             });
         });
 
-        // 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. One to
-            // another spender is under "an allowance to a spender other than
-            // the router" below.
-            test("a PERMIT2_PERMIT_BATCH of 5,000 USDT and unlimited DAI to the router, then a V3 exact-in of 600 USDT, shows each allowance", () => {
-                const result = decodeSteps(
-                    [0x03, 0x00],
-                    [
-                        encodePermit2Batch(
-                            [
-                                [USDT_ADDR, USDT_5000],
-                                [DAI_ADDR, MAX_UINT160],
-                            ],
-                            ROUTER_ADDR,
-                        ),
-                        V3_600,
-                    ],
-                );
-                expect(result.name).toBe("Swap USDT → USDC");
-                expect(linesBetweenTokens(result)).toEqual([
-                    ["Amount", "600.0000 USDT"],
-                    ...permitLines(
-                        "5000.0000 USDT",
-                        USDT_ADDR,
-                        "USDT",
-                        ROUTER_ADDR,
-                    ),
-                    ...permitLines("Unlimited", DAI_ADDR, "DAI", ROUTER_ADDR),
-                ]);
-                // 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 and no Min. received",
-                ({ command, input }) => {
-                    const result = decodeSteps(
-                        [command, 0x00],
-                        [input, V3_600],
-                    );
-                    expect(linesBetweenTokens(result)).toEqual([
-                        ...USDT_600_GROUP,
-                        ["Permit2 allowance", UNDECODED],
-                    ]);
-                    // Its spender may be any address, as with an allowance
-                    // to a spender other than the router (below).
-                    // https://git.eeqj.de/sneak/AutistMask/issues/658 — on
-                    // next at e296546 this read Min. received.
-                    expect(detail(result, "Min. received")).toBeUndefined();
-                    expect(detail(result, "Min. paid out").value).toBe(
-                        "590.0000 USDC",
-                    );
-                },
-            );
-
-            // https://git.eeqj.de/sneak/AutistMask/issues/659 — on next at
-            // 5f2b606 only the 400 DAI was shown.
-            test("a PERMIT2_PERMIT that cannot be read, then a V3 exact-in of 600 USDT and a V2 exact-in of 400 DAI, both paid by the user, shows both amounts", () => {
-                const result = decodeSteps(
-                    [0x0a, 0x00, 0x08],
-                    [
-                        dirtyWord(
-                            encodePermit2(USDT_ADDR, USDT_5000, ROUTER_ADDR),
-                            0,
-                        ),
-                        V3_600,
-                        encodeV2SwapExactIn(USER_ADDR, DAI_400, 390000000n, [
-                            DAI_ADDR,
-                            USDC_ADDR,
-                        ]),
-                    ],
-                );
-                expect(linesBetweenTokens(result)).toEqual([
-                    ...USDT_600_GROUP,
-                    ...DAI_GROUP,
-                    ["Permit2 allowance", UNDECODED],
-                ]);
-            });
-        });
-
-        // https://git.eeqj.de/sneak/AutistMask/issues/658 — code that a step
-        // runs can call a spender other than the router, which can then take
-        // up to its allowance from the sender before the transaction ends.
-        // On next at e296546 the Amount figure and Min. received took no
-        // account of it. An allowance of Token In to another spender now
-        // leaves no Amount figure, the swap steps' own takes get lines of
-        // their own, and any allowance to another spender leaves no Min.
-        // received.
-        describe("an allowance to a spender other than the router", () => {
-            const USDT_5000 = 5000000000n;
-            const DAI_5000 = 5000000000000000000000n;
-            const MAX_UINT160 = 2n ** 160n - 1n;
-            const USDT_5000_LINES = permitLines(
-                "5000.0000 USDT",
-                USDT_ADDR,
-                "USDT",
-                OTHER_ADDR,
-            );
-
-            test.each([
-                {
-                    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: [...USDT_600_GROUP, ...USDT_5000_LINES],
-                    minimum: "590.0000 USDC",
-                },
-                {
-                    kind: "a V3 exact-in of 600 USDT, then a PERMIT2_PERMIT of 5,000 USDT to another spender,",
-                    commands: [0x00, 0x0a],
-                    inputs: [
-                        V3_600,
-                        encodePermit2(USDT_ADDR, USDT_5000, OTHER_ADDR),
-                    ],
-                    lines: [...USDT_600_GROUP, ...USDT_5000_LINES],
-                    minimum: "590.0000 USDC",
-                },
-                {
-                    kind: "a PERMIT2_PERMIT_BATCH of 5,000 USDT and unlimited DAI to another spender, then a V3 exact-in of 600 USDT,",
-                    commands: [0x03, 0x00],
-                    inputs: [
-                        encodePermit2Batch(
-                            [
-                                [USDT_ADDR, USDT_5000],
-                                [DAI_ADDR, MAX_UINT160],
-                            ],
-                            OTHER_ADDR,
-                        ),
-                        V3_600,
-                    ],
-                    lines: [
-                        ...USDT_600_GROUP,
-                        ...USDT_5000_LINES,
-                        ...permitLines(
-                            "Unlimited",
-                            DAI_ADDR,
-                            "DAI",
-                            OTHER_ADDR,
-                        ),
-                    ],
-                    minimum: "590.0000 USDC",
-                },
-                {
-                    kind: "a PERMIT2_PERMIT of 1 USDT to another spender, then a V3 exact-in of 600 USDT and a V2 exact-in of 400 USDT, both paid by the user,",
-                    commands: [0x0a, 0x00, 0x08],
-                    inputs: [
-                        ONE_USDT_PERMIT(OTHER_ADDR),
-                        V3_600,
-                        encodeV2SwapExactIn(USER_ADDR, USDT_400, 390000000n, [
-                            USDT_ADDR,
-                            USDC_ADDR,
-                        ]),
-                    ],
-                    lines: [
-                        ...USDT_600_GROUP,
-                        ...USDT_400_GROUP,
-                        ...ONE_USDT_LINES(OTHER_ADDR),
-                    ],
-                    // The last swap step's minimum.
-                    minimum: "390.0000 USDC",
-                },
-            ])(
-                "$kind shows each take's own lines and the allowances, and no Amount figure or Min. received",
-                ({ commands, inputs, lines, minimum }) => {
-                    const result = decodeSteps(commands, inputs);
-                    expect(result.name).toBe("Swap USDT → USDC");
-                    expect(linesBetweenTokens(result)).toEqual(lines);
-                    expect(detail(result, "Paid to")).toBeUndefined();
-                    expect(detail(result, "Min. received")).toBeUndefined();
-                    expect(detail(result, "Min. paid out").value).toBe(minimum);
-                },
-            );
-
-            // An allowance of another token leaves the Amount figure for
-            // Token In.
-            test("a PERMIT2_PERMIT of 5,000 DAI to another spender, then a V3 exact-in of 600 USDT, shows the swap's 600 USDT and no Min. received", () => {
-                const result = decodeSteps(
-                    [0x0a, 0x00],
-                    [encodePermit2(DAI_ADDR, DAI_5000, OTHER_ADDR), V3_600],
-                );
-                expect(linesBetweenTokens(result)).toEqual([
-                    ["Amount", "600.0000 USDT"],
-                    ...permitLines(
-                        "5000.0000 DAI",
-                        DAI_ADDR,
-                        "DAI",
-                        OTHER_ADDR,
-                    ),
-                ]);
-                expect(detail(result, "Min. received")).toBeUndefined();
-                expect(detail(result, "Min. paid out").value).toBe(
-                    "590.0000 USDC",
-                );
-            });
-        });
-
         // 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.
@@ -2918,12 +2427,7 @@ describe("uniswap decoder", () => {
                 [USER_ADDR, 390000000n, USDT_400, "0x", true],
             );
             const result = decodeSteps([0x00, 0x01], [V3_600, unreadable]);
-            // With a V3 exact-out step, the 600 USDT reads as a maximum, as
-            // the Amount line would.
             expect(linesBetweenTokens(result)).toEqual([
-                ["Moved from the sender", "Up to 600.0000 USDT"],
-                ["Token moved", "USDT (" + USDT_ADDR + ")"],
-                ["Moved to", "The swap step that spends it"],
                 ["Moved from the sender", UNDECODED],
             ]);
             expect(detail(result, "Paid to").value).toBe(UNDECODED);
@@ -2974,9 +2478,6 @@ describe("uniswap decoder", () => {
                 ],
             );
             expect(linesBetweenTokens(result)).toEqual([
-                ["Moved from the sender", "Up to 0.5000 WETH"],
-                ["Token moved", "WETH (" + WETH_ADDR + ")"],
-                ["Moved to", "The swap step that spends it"],
                 ["Moved from the sender", UNDECODED],
                 ...permitLines("1.0000 WETH", WETH_ADDR, "WETH", ROUTER_ADDR),
             ]);
@@ -3132,15 +2633,14 @@ describe("uniswap decoder", () => {
         );
 
         // The V4 exact-out route above the other way round, where the later
-        // take's unknown amount leaves no Amount figure and the 400 USDT gets
+        // take's unknown amount leaves no figure at all, and other ways the
-        // lines of its own, and other ways the step that sets the input side
+        // step that sets the input side states no amount.
-        // states no amount.
         test.each([
             {
                 kind: "a V2 exact-out of at most 400 USDT, then a V4 exact-out step of at most 600 USDT",
                 commands: [0x09, 0x10],
                 inputs: [V2_EXACT_OUT_400, V4_EXACT_OUT_600],
-                lines: [...UP_TO_400_USDT, ...UNKNOWN_USDT],
+                lines: UNKNOWN_USDT,
             },
             {
                 kind: "a PERMIT2_PERMIT of 1 USDT to another spender, a V4 exact-out step of at most 600 USDT, then a V2 exact-out of at most 400 USDT",
@@ -3730,88 +3230,6 @@ describe("uniswap decoder", () => {
         },
     );
 
-    // https://git.eeqj.de/sneak/AutistMask/issues/574 — a V4 step that buys
-    // at least 0.5 WETH with 1,000 USDT, spends some of it on USDC, and takes
-    // the USDC and then the WETH, so its output side is WETH. Only what is
-    // left of the 0.5 WETH is sure to reach the user, and the screen read
-    // Min. received 0.5000 WETH.
-    test.each([
-        {
-            spend: "0.3 WETH for at least 594 USDC",
-            swap: {
-                id: V4_SWAP_EXACT_IN_SINGLE_ID,
-                param: encodeV4ExactInSingle(
-                    WETH_ADDR,
-                    USDC_ADDR,
-                    300000000000000000n,
-                    594000000n,
-                ),
-            },
-        },
-        {
-            spend: "0.3 WETH through DAI for at least 594 USDC",
-            swap: {
-                id: V4_SWAP_EXACT_IN,
-                param: encodeV4ExactIn(
-                    WETH_ADDR,
-                    [DAI_ADDR, USDC_ADDR],
-                    300000000000000000n,
-                    594000000n,
-                ),
-            },
-        },
-        {
-            spend: "at most 0.3 WETH for exactly 594 USDC",
-            swap: {
-                id: V4_SWAP_EXACT_OUT_SINGLE_ID,
-                param: encodeV4ExactOutSingle(
-                    WETH_ADDR,
-                    USDC_ADDR,
-                    594000000n,
-                    300000000000000000n,
-                ),
-            },
-        },
-    ])(
-        "a V4 step that buys WETH and spends $spend, with WETH as its output side, shows no Min. received",
-        ({ swap }) => {
-            const data = buildExecute(
-                "0x10",
-                [
-                    encodeV4Swap(
-                        new Uint8Array([
-                            USDT_FOR_WETH_IN.id,
-                            swap.id,
-                            V4_SETTLE_ALL_ID,
-                            V4_TAKE_ID,
-                            V4_TAKE_ID,
-                        ]),
-                        [
-                            USDT_FOR_WETH_IN.param,
-                            swap.param,
-                            encodeV4SettleAll(USDT_ADDR, 1000000000n),
-                            encodeV4Take(USDC_ADDR),
-                            encodeV4Take(WETH_ADDR),
-                        ],
-                    ),
-                ],
-                9999999999n,
-            );
-
-            const result = uniswap.decode(
-                data,
-                ROUTER_ADDR,
-                "0x1",
-                {},
-                USER_ADDR,
-            );
-            expect(result.name).toBe("Swap USDT → WETH");
-            expect(detail(result, "Amount").value).toBe("1000.0000 USDT");
-            expect(detail(result, "Token Out").address).toBe(WETH_ADDR);
-            expect(detail(result, "Min. received")).toBeUndefined();
-        },
-    );
-
     // A V4 step that spends WETH on USDC and on DAI. Its swap actions buy two
     // currencies that none of them spends, and CLOSE_CURRENCY, which the
     // decoder does not read, names no side, so its output side is unknown.

tests/uniswapRecipient.test.js

@@ -1332,10 +1332,6 @@ describe("any token left in the router is not received", () => {
                 ),
             ),
             left: tokenLine(WETH, "WETH"),
-            // The second swap action spends 1 USDC of what the first buys,
-            // so the step states no minimum
-            // (https://git.eeqj.de/sneak/AutistMask/issues/574).
-            noMin: true,
         },
         {
             kind: "a WRAP_ETH of 1 ETH into the router, then a V4 SETTLE of OPEN_DELTA from the router before the swap, which the user settles",
@@ -1436,24 +1432,15 @@ describe("any token left in the router is not received", () => {
             ),
             left: { label: "Token moved into the router", value: "ETH" },
         },
-    ])("$kind", ({ data, left, spent, unread, noMin }) => {
+    ])("$kind", ({ data, left, spent, unread }) => {
         const result = decode(data);
         expect(labels(result)).toEqual([
             "Protocol",
             "Token In",
             // A later step whose SETTLE or SETTLE_ALL the decoder cannot read
             // may take anything from the sender: one line says so, in place
-            // of the Amount line (https://git.eeqj.de/sneak/AutistMask/issues/625),
+            // of the Amount line (https://git.eeqj.de/sneak/AutistMask/issues/625).
-            // after the lines the WRAP_ETH's 1 ETH then gets
+            unread ? "Moved from the sender" : "Amount",
-            // (https://git.eeqj.de/sneak/AutistMask/issues/659).
-            ...(unread
-                ? [
-                      "Moved from the sender",
-                      "Token moved",
-                      "Moved to",
-                      "Moved from the sender",
-                  ]
-                : ["Amount"]),
             // A later swap step the user pays for spends `spent` of a token
             // other than Token In.
             ...(spent
@@ -1462,7 +1449,7 @@ describe("any token left in the router is not received", () => {
             "Token Out",
             "Paid to",
             "Token moved into the router",
-            ...(noMin ? [] : ["Min. paid out"]),
+            "Min. paid out",
             "Steps",
             "Deadline",
         ]);
@@ -1470,17 +1457,13 @@ describe("any token left in the router is not received", () => {
             expect(detail(result, "Moved from the sender").value).toBe(spent);
         }
         if (unread) {
-            expect(
+            expect(detail(result, "Moved from the sender").value).toBe(
-                result.details
+                UNDECODED,
-                    .filter((d) => d.label === "Moved from the sender")
+            );
-                    .map((d) => d.value),
-            ).toEqual(["1.0000 ETH", UNDECODED]);
         }
         expect(paidTo(result)).toEqual([STAYS_IN_ROUTER]);
         expect(detail(result, "Token moved into the router")).toEqual(left);
-        expect(detail(result, "Min. paid out")?.value).toBe(
+        expect(detail(result, "Min. paid out").value).toBe("1990.0000 USDC");
-            noMin ? undefined : "1990.0000 USDC",
-        );
     });
 
     // Uniswap's own routes: a swap paid in ETH wraps into the router what its
@@ -2808,37 +2791,26 @@ describe("the allow-revert flag", () => {
     });
 
     // Only the routers from UniversalRouterV2 on let a PERMIT2_PERMIT fail.
-    // The permit's spender is the router at ROUTER, which on every other
-    // router is an allowance to another spender, so the minimum reads
-    // Min. paid out there.
     test.each([
-        {
+        { router: "UniversalRouterV1", address: ROUTER_V1, mark: "" },
-            router: "UniversalRouterV1",
-            address: ROUTER_V1,
-            mark: "",
-            minimum: "Min. paid out",
-        },
         {
             router: "UniversalRouterV1_2_V2Support",
             address: ROUTER_V1_2,
             mark: "",
-            minimum: "Min. paid out",
         },
         {
             router: "UniversalRouterV2",
             address: ROUTER,
             mark: " (allowed to fail)",
-            minimum: "Min. received",
         },
         {
             router: "UniversalRouterV2_1_2",
             address: ROUTER_V2_1_2,
             mark: " (allowed to fail)",
-            minimum: "Min. paid out",
         },
     ])(
         "on $router, a PERMIT2_PERMIT with the flag is listed as 'Permit2 Permit$mark', and the swap's lines read as without the flag",
-        ({ address, mark, minimum }) => {
+        ({ address, mark }) => {
             const steps = [
                 permit2Permit(USDT, USDT_2000),
                 swapToWeth(MSG_SENDER),
@@ -2870,7 +2842,7 @@ describe("the allow-revert flag", () => {
             expect(
                 labels(withFlag).filter((l) => permitLines.includes(l)),
             ).toEqual(permitLines);
-            expect(detail(withFlag, minimum).value).toBe("1.0000 WETH");
+            expect(detail(withFlag, "Min. received").value).toBe("1.0000 WETH");
         },
     );