fix: a split swap's Min. received is the sum of its steps' minimums (closes #647)

The step that sets the output side gives the minimum. When that step
and earlier swap steps each pay the output token to the sender, the
minimum is now the sum of their minimums. There is no figure when the
decoder reads none from one of them, or when one of them pays part of
that token elsewhere.

These steps drop earlier steps from the sum:

- a V2 or V3 swap step that spends the output token;
- a V4 step with a swap action that spends that token, or with a SETTLE
  or SETTLE_ALL of that token;
- a PERMIT2_TRANSFER_FROM of that token.

A step after the step that sets the output side drops nothing from the
sum.

Model: opus-5-5

README.md

@@ -1266,7 +1266,8 @@ see Transaction Decoding), do not always read as a number. They can read:
   the same words. `Unlimited`, `All available (V4 open delta)` and
   `Whatever an earlier step sent to the pair (V2 already paid)` keep their
   wording. When a V2 or V3 exact-out step sets `Min. received`, that line shows
-  its `amountOut`, the exact amount it buys.
+  its `amountOut`, the exact amount it buys. When earlier swap steps also pay
+  that token to the user, the line shows the sum (see Transaction Decoding).
 - `All available (V4 open delta)`: the swap's `Amount` line, when the amount it
   shows is a V4 exact-in `amountIn` of zero. V4 reads that zero as "use the
   whole open delta", so the calldata states no quantity. Transaction Decoding
@@ -1277,22 +1278,18 @@ see Transaction Decoding), do not always read as a number. They can read:
   step pays nothing itself and swaps whatever an earlier step sent to the pair,
   so the calldata states no quantity. A V3 exact-in `amountIn` of zero has no
   such meaning and is shown as a zero.
-- `None (no minimum guaranteed)`: the swap's `Min. received` line, when the
-  minimum it shows is zero, whether a V2, V3 or V4 swap's minimum or a
-  `BALANCE_CHECK_ERC20` step's `minBalance`. Before
-  [#359](https://git.eeqj.de/sneak/AutistMask/issues/359), a zero `minBalance`
-  read `0.0000` when the token's scale was known. The router passes a balance
-  check whenever the balance is at least `minBalance`, so a zero `minBalance`
-  guarantees nothing: it sets `Token Out` and `Min. received` only when the
-  output side holds no minimum, not even a zero one, at the point the check is
-  reached, and otherwise leaves the current token and figure in place. A nonzero
-  `minBalance` sets both lines, as a swap step does. Only a check of the
-  transaction's sender's own balance sets either line; a check of any other
-  address sets neither (see Transaction Decoding). A `BALANCE_CHECK_ERC20` step
-  that the router lets fail without reverting the transaction (see Transaction
-  Decoding) guarantees nothing either, whatever its `minBalance`, and is read as
-  one whose `minBalance` is zero. A minimum stated by a V4 swap step the router
-  lets fail is likewise read as zero.
+- `None (no minimum guaranteed)`: the swap's `Min. received` line, when it shows
+  a V2, V3 or V4 swap's minimum of zero. The router passes a
+  `BALANCE_CHECK_ERC20` step whenever the balance is at least `minBalance`, so a
+  zero `minBalance` guarantees nothing. A check with a zero `minBalance` sets
+  neither `Token Out` nor `Min. received`. A nonzero `minBalance` sets both
+  lines, as a swap step does. Only a check of the transaction's sender's own
+  balance sets either line; a check of any other address sets neither (see
+  Transaction Decoding). A `BALANCE_CHECK_ERC20` step that the router lets fail
+  without reverting the transaction (see Transaction Decoding) guarantees
+  nothing either, whatever its `minBalance`, and is read as one whose
+  `minBalance` is zero. A minimum stated by a V4 swap step the router lets fail
+  is likewise read as zero.
 
 The swap's `Token In` and `Token Out` lines name a currency, not an amount; each
 reads `Unknown (not named in the calldata)` when the decoder found no token for
@@ -2281,6 +2278,8 @@ view would leave a wallet one click from deletion.
         - Endpoint URL input + "Save" button. "Save" asks the URL for `/stats`
           and saves the URL only if that request succeeds. The request carries
           no user data and is made whether or not "Use Blockscout" is ticked.
+    - If the network changes before either "Save" stores its URL, the URL is not
+      saved and a flash message says so
     - Etherscan:
         - "Check recipients on Etherscan" checkbox, unticked until the user
           ticks it
@@ -3395,7 +3394,8 @@ Currently supported:
   `Balance Check (of another address)`. A check whose input does not decode,
   such as one whose owner word has a nonzero top byte (the router reads the
   owner from the word's last 20 bytes), likewise sets neither, and it is listed
-  as `Balance Check (could not be decoded)`. When a swap step, `TAKE` or
+  as `Balance Check (could not be decoded)`. A check with a zero `minBalance`
+  sets neither `Token Out` nor the minimum. When a swap step, `TAKE` or
   `TAKE_PORTION` pays the router any token, the swap's output or another, a
   `WRAP_ETH` pays it WETH, or an `UNWRAP_WETH` into the router turns WETH a step
   paid it into ETH, that token stays in the router unless a later step pays out
@@ -3460,19 +3460,29 @@ Currently supported:
   name); and one more reads `Unknown (could not be decoded)` when a step that
   may pay an address went unread. When no step pays anyone, a single line reads
   `Unknown (not named in the calldata)`. Wherever there is a `Paid to` line, the
-  minimum reads `Min. paid out`. The `Amount` line gives the total the steps
-  take of `Token In`, from the step that sets the input side on: the first V2 or
-  V3 exact-in or exact-out, `WRAP_ETH` or V4 swap step that names an input token
-  or amount. A V4 step with a swap action sets the input side when no earlier
-  step set it, even when it names neither (see Display Consistency). That step
-  counts its own amount, whoever pays it: a V2 or V3 exact-out step its
-  `amountInMax`, and a V4 step what it takes of its input token from the user's
-  wallet, as below, or, when the user pays it none of that token, the `amountIn`
-  of the swap action that spends it. Each later V2 or V3 exact-in or exact-out
-  step whose `payerIsUser` is true takes its amount, found in the same way, from
-  the user's wallet. Every V4 step, with a swap action or without, takes from
-  the user's wallet what its `SETTLE`s paid by the user (`payerIsUser` true) and
-  its `SETTLE_ALL`s pay, for each token on its own; what the step that sets the
+  minimum reads `Min. paid out`. The step that sets the output side gives the
+  minimum. When that step and earlier swap steps each pay the output token to
+  the transaction's sender, the minimum is the sum of their minimums. There is
+  no minimum when the decoder reads none from one of them, or when one of them
+  pays part of that token elsewhere. There is also no minimum when the decoder
+  did not read one of them, or a step between them, in full. A swap step that
+  spends the output token drops earlier steps from the sum. A V4 step spends
+  each token that its swap actions spend. A V4 `SETTLE` or `SETTLE_ALL` of the
+  output token also drops earlier steps. A `PERMIT2_TRANSFER_FROM` of the output
+  token drops earlier steps too. A step after the step that sets the output side
+  drops nothing from the sum. The `Amount` line gives the total the steps take
+  of `Token In`, from the step that sets the input side on: the first V2 or V3
+  exact-in or exact-out, `WRAP_ETH` or V4 swap step that names an input token or
+  amount. A V4 step with a swap action sets the input side when no earlier step
+  set it, even when it names neither (see Display Consistency). That step counts
+  its own amount, whoever pays it: a V2 or V3 exact-out step its `amountInMax`,
+  and a V4 step what it takes of its input token from the user's wallet, as
+  below, or, when the user pays it none of that token, the `amountIn` of the
+  swap action that spends it. Each later V2 or V3 exact-in or exact-out step
+  whose `payerIsUser` is true takes its amount, found in the same way, from the
+  user's wallet. Every V4 step, with a swap action or without, takes from the
+  user's wallet what its `SETTLE`s paid by the user (`payerIsUser` true) and its
+  `SETTLE_ALL`s pay, for each token on its own; what the step that sets the
   input side takes of any other token counts as a later step's take. A `SETTLE`
   of any amount but `OPEN_DELTA` pays that amount, and a `SETTLE` of
   `OPEN_DELTA` or a `SETTLE_ALL` pays what the step owes, as above. So a V4 step
@@ -3564,10 +3574,14 @@ Currently supported:
   on every router but `UniversalRouterV1`, and otherwise gives the address. A
   move into the router needs none of them, because its `Paid to` line and
   `Token moved into the router` line already give the amount, the token and
-  where it goes, and so its amount is shown once. Every `PERMIT2_PERMIT` whose
-  amount does not stand as the `Amount` figure, before the step that sets the
-  input side or after it, gives three lines, in step order, after those for each
-  `PERMIT2_TRANSFER_FROM`: `Permit2 allowance`, its amount, for example
+  where it goes, and so its amount is shown once. For a move of the zero
+  address, `Moved from the sender` gives the amount in base units and
+  `Token moved` gives the zero address. For such a move into the router, the
+  `Paid to` line gives the amount in base units and
+  `Token moved into the router` gives the zero address. Every `PERMIT2_PERMIT`
+  whose amount does not stand as the `Amount` figure, before the step that sets
+  the input side or after it, gives three lines, in step order, after those for
+  each `PERMIT2_TRANSFER_FROM`: `Permit2 allowance`, its amount, for example
   `5000.0000 DAI`, or `Unlimited` for Permit2's maximum; `Allowance token`,
   giving the token's address as the `Token In` line does; and
   `Allowance spender`, the address it lets take the token. Only a permit whose

src/popup/views/settings.js

@@ -44,6 +44,12 @@ let ctx;
 let versionClickCount = 0;
 let versionClickTimer = null;
 
+// The network that Settings was last drawn for. A follow of a switch saved
+// elsewhere sets `state` to the new network first. Settings is drawn again only
+// once the follow's write returns. So both "Save" buttons take this network,
+// not the one in `state`.
+let shownNetwork = null;
+
 // One row per site origin, however many addresses it appears under, each with
 // an [x] that hands it to onRemove.
 function renderSiteList(containerId, origins, onRemove) {
@@ -199,6 +205,7 @@ function renderWalletListSettings() {
 }
 
 function show() {
+    shownNetwork = currentNetwork();
     $("settings-rpc").value = state.rpcUrl;
     $("settings-blockscout").value = state.blockscoutUrl;
     $("settings-network").value = state.networkId;
@@ -306,6 +313,7 @@ function showNewSettings() {
         state.checkRecipientsOnEtherscan;
     if (state.currentView === "settings") {
         markViewRendered("settings");
+        shownNetwork = currentNetwork();
         $("settings-network").value = state.networkId;
         $("settings-rpc").value = state.rpcUrl;
         $("settings-blockscout").value = state.blockscoutUrl;
@@ -319,6 +327,28 @@ function showNewSettings() {
     updateDebugBanner(state.currentView);
 }
 
+// Saves `url` as `field` ("rpcUrl" or "blockscoutUrl") of the network
+// `networkId`, the one that Settings showed when the user tapped "Save". The
+// URL is set in `state` inside the save, holding the lock. So the page cannot
+// follow a switch saved elsewhere (followStoredSettings() in
+// src/popup/index.js) between setting the URL and writing it. If the active
+// network is no longer `networkId`, on this page or in the stored record,
+// nothing is saved. The flash message then says that the network changed.
+async function saveEndpoint(field, url, networkId) {
+    let refused = false;
+    await saveState((stored) => {
+        refused =
+            state.networkId !== networkId || stored.networkId !== networkId;
+        if (refused) return false;
+        state[field] = url;
+    });
+    if (refused) {
+        showFlash("The URL was not saved because the network changed.");
+    } else {
+        showFlash("Saved.");
+    }
+}
+
 function init(_ctx) {
     ctx = _ctx;
     deleteWallet.init(ctx);
@@ -330,6 +360,8 @@ function init(_ctx) {
             showFlash("Please enter an RPC URL.");
             return;
         }
+        // The URL is for the network that Settings shows when "Save" is tapped.
+        const net = shownNetwork;
         showFlash("Testing endpoint...");
         try {
             const resp = await debugFetch(url, {
@@ -348,7 +380,6 @@ function init(_ctx) {
                 showFlash("Endpoint returned an error.");
                 return;
             }
-            const net = currentNetwork();
             if (json.result !== net.chainId) {
                 showFlash("Wrong network: expected " + net.name + ".");
                 return;
@@ -364,9 +395,7 @@ function init(_ctx) {
             showFlash("Could not reach endpoint.");
             return;
         }
-        state.rpcUrl = url;
-        await saveState();
-        showFlash("Saved.");
+        await saveEndpoint("rpcUrl", url, net.id);
     });
 
     $("btn-save-blockscout").addEventListener("click", async () => {
@@ -375,6 +404,7 @@ function init(_ctx) {
             showFlash("Please enter a Blockscout API URL.");
             return;
         }
+        const net = shownNetwork;
         showFlash("Testing endpoint...");
         try {
             const resp = await debugFetch(url + "/stats");
@@ -389,9 +419,7 @@ function init(_ctx) {
             showFlash("Could not reach endpoint.");
             return;
         }
-        state.blockscoutUrl = url;
-        await saveState();
-        showFlash("Saved.");
+        await saveEndpoint("blockscoutUrl", url, net.id);
     });
 
     // Each change is made inside the save, holding the lock. So

src/shared/chainSwitch.js

@@ -47,12 +47,30 @@ function clearPopupCaches() {
 // lock, so it is never switched while a follow of a switch saved elsewhere
 // waits for the lock (followStoredSettings() in src/popup/index.js): that
 // follow runs first, and this switch is made after it.
+//
+// The save writes only the fields that differ from what this page last saved.
+// When this page last saved a balance of "0", clearing that balance is no
+// change. So the switch also resets these fields in the stored record:
+//
+// - every address's balance and token balances;
+// - the time of the last balance refresh.
+//
+// A balance that the background or another page stored since this page's last
+// save is then not kept under the new network
+// (https://git.eeqj.de/sneak/AutistMask/issues/653).
 async function onChainSwitch(newNetworkId) {
     const { state, saveState } = require("./state");
     let net = null;
-    await saveState(() => {
+    await saveState((stored) => {
         if (state.networkId === newNetworkId) return false;
         net = applyChainSwitchFields(state, newNetworkId);
+        stored.lastBalanceRefresh = 0;
+        for (const wallet of stored.wallets) {
+            for (const addr of wallet.addresses) {
+                addr.balance = "0";
+                addr.tokenBalances = [];
+            }
+        }
         clearPopupCaches();
     });
     return net;

src/shared/state.js

@@ -591,8 +591,10 @@ function reportSaveFailure(err) {
 //
 // `beforeWrite`, when given, is called inside the lock with the stored record
 // as just read, before this page's state is compared against it. It may change
-// `state`, and this save writes that change. When it returns false, nothing is
-// written; any other return lets the save go ahead.
+// `state`, and this save writes that change. It may also change the stored
+// record. A field that this page did not change is then written as
+// `beforeWrite` left it. When it returns false, nothing is written; any other
+// return lets the save go ahead.
 function saveState(beforeWrite) {
     const turn = withLock("autistmask", () => saveStateOnce(beforeWrite));
     // Every failed save is reported, whether or not the caller awaited this

src/shared/uniswap.js

@@ -479,6 +479,17 @@ function tokenInfo(address, sources) {
     };
 }
 
+// The token of a Permit2 allowance or of a PERMIT2_TRANSFER_FROM, in the
+// shape tokenInfo() gives. Permit2 has no allowance of ETH and moves no ETH.
+// The zero address there reads as a token nothing knows: its amount in base
+// units, and the zero address as its token.
+function permit2TokenInfo(address, sources) {
+    if (address === "0x0000000000000000000000000000000000000000") {
+        return { symbol: null, decimals: null, address };
+    }
+    return tokenInfo(address, sources);
+}
+
 // A swap amount line. With a scale it is the token quantity; with none it is
 // the base-unit integer with the unknown scale stated, the same refusal the
 // ERC-20 amount line makes, so the screen has one way of saying it. `display`
@@ -497,16 +508,18 @@ function amountText(raw, info) {
 
 // The line giving a moved token, or the token of a permit, under `label`, in
 // the shape of the Token In line, so the screens show it as they show that
-// one. ETH has no address.
-function tokenMovedLine(label, token, sources) {
-    const info = tokenInfo(token, sources);
+// one. `info` is what tokenInfo() or permit2TokenInfo() gives for the token.
+// ETH has no address.
+function tokenMovedLine(label, info) {
     if (!present(info.address)) {
         return { label, value: info.symbol };
     }
     return {
         label,
-        value: info.symbol ? info.symbol + " (" + token + ")" : token,
-        address: token,
+        value: info.symbol
+            ? info.symbol + " (" + info.address + ")"
+            : info.address,
+        address: info.address,
         isToken: true,
     };
 }
@@ -975,6 +988,9 @@ function totalAmount(amounts) {
 // pays it of Token In as the step's amount in place of the rules' Amount, or
 // no amount when this decoder cannot tell what that is.
 //
+// `spent` lists the currency that each swap action spends, for each swap
+// action that this decoder could read.
+//
 // `takes` is every TAKE, TAKE_ALL and TAKE_PORTION, as the currency it takes
 // and its recipient as written, MSG_SENDER for a TAKE_ALL. TAKE_PORTION takes
 // a share of the currency, so it does not name the output side as TAKE does.
@@ -1150,6 +1166,8 @@ function decodeV4Swap(input) {
             }
         }
 
+        const spent = swaps.map((s) => s.tokenIn);
+
         // Rule 3.
         if (swapUndecoded) {
             return {
@@ -1157,6 +1175,7 @@ function decodeV4Swap(input) {
                 tokenOut: takeToken,
                 amountIn: null,
                 amountOutMin: null,
+                spent,
                 takes,
                 settledFromRouter,
                 paidByUser,
@@ -1167,7 +1186,6 @@ function decodeV4Swap(input) {
             };
         }
 
-        const spent = swaps.map((s) => s.tokenIn);
         const bought = swaps.map((s) => s.tokenOut);
 
         // Rules 1 and 2 for Token In.
@@ -1203,6 +1221,7 @@ function decodeV4Swap(input) {
             tokenOut,
             amountIn,
             amountOutMin,
+            spent,
             takes,
             settledFromRouter,
             paidByUser,
@@ -1294,8 +1313,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         const commandNames = [];
 
         // THE INVARIANT: an amount and the token it is counted in always come
-        // from the same hop, or from hops that all spend that token. A figure
-        // is never rendered against a token that did not supply it.
+        // from the same hop, or from hops that all spend that token or all buy
+        // it. A figure is never rendered against a token that did not supply
+        // it.
         //
         // Both sides are therefore set as a PAIR — never field by field, and
         // never on truthiness. An address is never falsy once set but an
@@ -1410,6 +1430,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             const r = recipient.toLowerCase();
             return r === ADDRESS_THIS || r === toAddress.toLowerCase();
         };
+        const isSender = (recipient) => {
+            const r = recipient.toLowerCase();
+            return r === MSG_SENDER || r === sender;
+        };
         // A swap step or V4 SETTLE pays `amount` of `token` from the router's
         // own balance. CONTRACT_BALANCE pays all of it. Any other quantity
         // counts against the amount a WRAP_ETH stated, and the steps pay all
@@ -1442,17 +1466,73 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // A step pays `recipient`. `output` is the token a swap step or a V4
         // TAKE or TAKE_PORTION pays; other steps pass none.
         const addPayee = (recipient, output) => {
-            const r = recipient.toLowerCase();
             if (isRouter(recipient)) {
                 if (present(output)) {
                     heldByRouter.set(output.toLowerCase(), null);
                 }
-            } else if (r === MSG_SENDER || r === sender) {
+            } else if (isSender(recipient)) {
                 paidToSender = true;
             } else {
                 addPaidElsewhere(recipient);
             }
         };
+        // Each swap step that paid the sender some of the token it bought,
+        // as { step, token, amount, onlyToSender }:
+        // - `step` is the step's index;
+        // - `token` is that token;
+        // - `amount` is the step's stated minimum;
+        // - `onlyToSender` is whether the step paid all of that token to the
+        //   sender.
+        // A later step that spends that token takes the step off this list
+        // (see dropFromSum()).
+        let swapsPayingSender = [];
+        // The step being read spends `token`, so it may spend what an earlier
+        // swap step paid the sender. Each step on swapsPayingSender that
+        // bought `token` leaves the list. A step spends a token as follows:
+        // - a V2 or V3 swap step spends its input token;
+        // - a V4 step spends each token that one of its swap actions spends,
+        //   and each token that one of its SETTLEs or SETTLE_ALLs pays;
+        // - a PERMIT2_TRANSFER_FROM spends the token it moves.
+        const dropFromSum = (token) => {
+            swapsPayingSender = swapsPayingSender.filter(
+                (s) => !sameAddress(s.token, token),
+            );
+        };
+        // The minimum the output side shows for the swap step at `step`. The
+        // step buys `token` with the stated minimum `amount`, and pays
+        // `token` to `recipients`. The minimum is the step's own, unless this
+        // step and an earlier one on swapsPayingSender both pay `token` to
+        // the sender, as a route split across steps does. The minimum is then
+        // the total of all such steps' minimums. There is none when this
+        // decoder reads no minimum from one of them, or when one of them pays
+        // some of `token` elsewhere. There is also none when this decoder did
+        // not read one of them, or a step between them, in full (see
+        // stepsUnread).
+        const swapMinimum = (step, token, amount, recipients) => {
+            const toSender = recipients.filter(
+                (r) => present(r) && isSender(r),
+            );
+            if (toSender.length === 0) return amount;
+            swapsPayingSender.push({
+                step,
+                token,
+                amount,
+                onlyToSender: toSender.length === recipients.length,
+            });
+            const split = swapsPayingSender.filter((s) =>
+                sameAddress(s.token, token),
+            );
+            if (split.length < 2) return amount;
+            if (
+                split.some(
+                    (s) => !s.onlyToSender || typeof s.amount !== "bigint",
+                ) ||
+                stepsUnread.some((unread) => unread >= split[0].step)
+            ) {
+                return null;
+            }
+            return split.reduce((sum, s) => sum + s.amount, 0n);
+        };
         // A step that pays `token` to `recipient` is a hop, not a payout,
         // when the very next step is a V2 exact-in whose input is already
         // paid, whose path starts at `token`, and whose pair (see v2PairFor())
@@ -1594,6 +1674,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                                     : null,
                         });
                     }
+                    if (p) dropFromSum(p.token);
                 } else if (command === "BALANCE_CHECK_ERC20") {
                     const b = decodeBalanceCheck(inputs[i]);
                     if (!b) {
@@ -1616,13 +1697,13 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     } else {
                         // The router passes this check whenever the owner
                         // holds at least minBalance, so a zero one guarantees
-                        // nothing and does not replace a minimum an earlier
-                        // step stated. A check the router lets fail guarantees
-                        // nothing either, so it is read as a zero one. Any
+                        // nothing. A check the router lets fail guarantees
+                        // nothing either, so it is read as a zero one. A zero
+                        // check sets neither Token Out nor the minimum. Any
                         // other minBalance sets the output side as a swap
-                        // does. It pays nobody.
+                        // does. The check pays nobody.
                         const minBalance = allowedToFail ? 0n : b.minBalance;
-                        if (!(minBalance === 0n && present(minOutput))) {
+                        if (minBalance !== 0n) {
                             setOutput(i, b.token, minBalance, []);
                         }
                         keepsRouterWeth = true;
@@ -1636,10 +1717,18 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountIn);
                         }
+                        dropFromSum(s.tokenIn);
                         // Always update output: in multi-step swaps (V3 → V4),
-                        // the last swap step determines the final output token
-                        // and minimum received amount.
-                        setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
+                        // the last swap step determines the final output
+                        // token. swapMinimum() gives the minimum.
+                        setOutput(
+                            i,
+                            s.tokenOut,
+                            swapMinimum(i, s.tokenOut, s.amountOutMin, [
+                                s.recipient,
+                            ]),
+                            [s.recipient],
+                        );
                         if (!s.payerIsUser) {
                             spendFromRouter(s.tokenIn, s.amountIn);
                         }
@@ -1660,7 +1749,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountIn);
                         }
-                        setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
+                        dropFromSum(s.tokenIn);
+                        setOutput(
+                            i,
+                            s.tokenOut,
+                            swapMinimum(i, s.tokenOut, s.amountOutMin, [
+                                s.recipient,
+                            ]),
+                            [s.recipient],
+                        );
                         if (!s.payerIsUser) {
                             spendFromRouter(s.tokenIn, s.amountIn);
                         }
@@ -1692,7 +1789,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         } else if (s.payerIsUser) {
                             addUserPaid(s.tokenIn, s.amountInMax);
                         }
-                        setOutput(i, s.tokenOut, s.amountOut, [s.recipient]);
+                        dropFromSum(s.tokenIn);
+                        setOutput(
+                            i,
+                            s.tokenOut,
+                            swapMinimum(i, s.tokenOut, s.amountOut, [
+                                s.recipient,
+                            ]),
+                            [s.recipient],
+                        );
                         if (!isHop(i, s.tokenOut, s.recipient)) {
                             addPayee(s.recipient, s.tokenOut);
                         }
@@ -1864,6 +1969,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                                 addPayee(t.recipient, t.currency);
                             }
                         }
+                        for (const token of v4.spent) dropFromSum(token);
+                        for (const s of v4.paidByUser) dropFromSum(s.currency);
+                        for (const s of v4.settledFromRouter) {
+                            dropFromSum(s.currency);
+                        }
                     }
                     if (!v4 || v4.recipientUnread) {
                         payeeUnread = true;
@@ -1912,7 +2022,12 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                             setInput(v4.tokenIn, amountIn);
                         }
                         outputToken = v4.tokenOut;
-                        minOutput = v4.amountOutMin;
+                        minOutput = swapMinimum(
+                            i,
+                            v4.tokenOut,
+                            v4.amountOutMin,
+                            takeRecipients,
+                        );
                         outputEstablished = true;
                         outputUnwrapped = false;
                         unwrapIntoRouterStep = null;
@@ -2329,7 +2444,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     : UNDECODED_CURRENCY,
             });
             if (present(s.token)) {
-                details.push(tokenMovedLine("Token moved", s.token, sources));
+                details.push(
+                    tokenMovedLine("Token moved", tokenInfo(s.token, sources)),
+                );
                 details.push({
                     label: "Moved to",
                     value: "The swap step that spends it",
@@ -2340,12 +2457,12 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // What each PERMIT2_TRANSFER_FROM moves: its amount, its token and
         // where it goes, an address on a line of its own.
         for (const m of movedFromSender) {
+            const info = permit2TokenInfo(m.token, sources);
             details.push({
                 label: "Moved from the sender",
-                value: amountText(m.amount, tokenInfo(m.token, sources))
-                    .display,
+                value: amountText(m.amount, info).display,
             });
-            details.push(tokenMovedLine("Token moved", m.token, sources));
+            details.push(tokenMovedLine("Token moved", info));
             details.push(
                 present(m.to)
                     ? { label: "Moved to", value: m.to }
@@ -2375,36 +2492,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 });
                 continue;
             }
-            // Permit2 has no allowance of ETH. An allowance of the zero
-            // address reads as one of a token nothing knows: its amount in
-            // base units, and the zero address as its token.
-            if (p.token === "0x0000000000000000000000000000000000000000") {
-                details.push({
-                    label: "Permit2 allowance",
-                    value:
-                        p.amount >= MAX_UINT160
-                            ? "Unlimited"
-                            : unknownDecimalsAmount(p.amount),
-                });
-                details.push({
-                    label: "Allowance token",
-                    value: p.token,
-                    address: p.token,
-                    isToken: true,
-                });
-            } else {
-                details.push({
-                    label: "Permit2 allowance",
-                    value:
-                        p.amount >= MAX_UINT160
-                            ? "Unlimited"
-                            : amountText(p.amount, tokenInfo(p.token, sources))
-                                  .display,
-                });
-                details.push(
-                    tokenMovedLine("Allowance token", p.token, sources),
-                );
-            }
+            const info = permit2TokenInfo(p.token, sources);
+            details.push({
+                label: "Permit2 allowance",
+                value:
+                    p.amount >= MAX_UINT160
+                        ? "Unlimited"
+                        : amountText(p.amount, info).display,
+            });
+            details.push(tokenMovedLine("Allowance token", info));
             details.push({
                 label: "Allowance spender",
                 value: p.spender,
@@ -2462,7 +2558,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             paidTo.push({ label: "Paid to", value: PAID_TO_BRIDGE });
         }
         for (const m of movedIntoRouter) {
-            const info = tokenInfo(m.token, sources);
+            const info = permit2TokenInfo(m.token, sources);
             paidTo.push({
                 label: "Paid to",
                 value:
@@ -2470,9 +2566,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     amountText(m.amount, info).display +
                     " from the sender (later steps may not spend all of it)",
             });
-            paidTo.push(
-                tokenMovedLine("Token moved into the router", m.token, sources),
-            );
+            paidTo.push(tokenMovedLine("Token moved into the router", info));
         }
         if (outputHeld) {
             paidTo.push({ label: "Paid to", value: STAYS_IN_ROUTER });
@@ -2489,8 +2583,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             paidTo.push(
                 tokenMovedLine(
                     "Token moved into the router",
-                    getAddress(token),
-                    sources,
+                    tokenInfo(getAddress(token), sources),
                 ),
             );
         }

tests/balanceRefreshNetworkSwitch.test.js

@@ -6,6 +6,10 @@
 // approved a site's request, which changes only the stored record. Driven
 // through the real popup over a stored profile on Ethereum Mainnet. The same
 // refresh in the background is in tests/backgroundStateIsolation.test.js.
+//
+// The last test covers a balance refresh by the background that is saved while
+// a switch in Settings waits for the lock
+// (https://git.eeqj.de/sneak/AutistMask/issues/653).
 
 const {
     bootPopup,
@@ -159,3 +163,50 @@ test("a refresh that returns after the background switched the network writes no
 
     expectNothingStored(page);
 });
+
+// The background's refresh saves Ethereum Mainnet's balances while the switch
+// in Settings waits for the lock. This page last saved a balance of "0" and no
+// token balances, the values that the switch sets.
+test("a background refresh saved while a switch in Settings waits for the lock leaves none of its balances stored", async () => {
+    const profile = unversionedValidProfile();
+    profile.wallets[0].addresses[0].balance = "0";
+    const page = await bootPopup(profile);
+    expect(page.pageErrors).toEqual([]);
+    const background = require("../src/background/state");
+    await page.click("btn-settings");
+
+    // The background takes the lock first and holds it until the test calls
+    // `letGo()`. It then saves balances as backgroundRefresh() in
+    // src/background/index.js does.
+    let letGo;
+    const refreshSave = background.updateState(async (fresh) => {
+        await new Promise((resolve) => {
+            letGo = resolve;
+        });
+        fresh.wallets[0].addresses[0].balance = "7.0";
+        fresh.wallets[0].addresses[0].tokenBalances = [
+            {
+                address: TOKEN_ADDRESS,
+                name: "Test Token",
+                symbol: "TST",
+                decimals: 18,
+                balance: "5.0",
+                holders: null,
+            },
+        ];
+        fresh.lastBalanceRefresh = Date.now();
+    });
+    await page.settle();
+
+    const select = page.node("settings-network");
+    select.value = "sepolia";
+    const switching = Promise.all(select.listeners.change.map((fn) => fn()));
+    await page.settle();
+
+    letGo();
+    await refreshSave;
+    await switching;
+    await page.settle();
+
+    expectNothingStored(page);
+});

tests/popupFollowsNetworkSwitch.test.js

@@ -253,6 +253,271 @@ test("a switch back in Settings after a follow whose write failed is stored", as
     expect(told.at(-1).chainId).toBe(NETWORKS.mainnet.chainId);
 });
 
+// The user saves an endpoint URL in Settings on Ethereum Mainnet. Before the
+// URL is stored, the background saves a switch to Sepolia. Another write holds
+// the lock, so the popup's follow of that switch and the URL's save both wait
+// for the lock. Either may take it first. The URL is stored for neither
+// network. The flash message says that the network changed.
+test.each([
+    { button: "btn-save-rpc", field: "settings-rpc", first: "follow" },
+    { button: "btn-save-rpc", field: "settings-rpc", first: "save" },
+    {
+        button: "btn-save-blockscout",
+        field: "settings-blockscout",
+        first: "follow",
+    },
+    {
+        button: "btn-save-blockscout",
+        field: "settings-blockscout",
+        first: "save",
+    },
+])(
+    "$button saves nothing when the network changes before the URL is stored ($first first)",
+    async ({ button, field, first }) => {
+        const page = await bootOnAddress();
+        await page.click("btn-settings");
+        // This answer passes both endpoint checks. The RPC check reads
+        // Ethereum Mainnet's chain id from it. The Blockscout check reads `ok`.
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ result: NETWORKS.mainnet.chainId }),
+        });
+        const url = "https://own-node.example.invalid";
+
+        let releaseLock;
+        const lockHeld = navigator.locks.request(
+            "autistmask",
+            () =>
+                new Promise((resolve) => {
+                    releaseLock = resolve;
+                }),
+        );
+        // The click handler runs until its save waits for the lock.
+        const tapSave = async () => {
+            page.node(field).value = url;
+            const saving = page.node(button).listeners.click.map((fn) => fn());
+            await page.settle();
+            return saving;
+        };
+        let saving;
+        if (first === "save") saving = await tapSave();
+        await backgroundSwitch(page, "sepolia");
+        if (first === "follow") saving = await tapSave();
+        releaseLock();
+        await lockHeld;
+        await Promise.all(saving);
+        await page.settle();
+
+        const { state } = require("../src/shared/state");
+        expect(state.networkId).toBe("sepolia");
+        expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(
+            url,
+        );
+        expect(page.text("flash-msg")).toBe(
+            "The URL was not saved because the network changed.",
+        );
+    },
+);
+
+// The popup's follow of the background's switch to Sepolia has set `state` to
+// Sepolia. The follow's write has not returned yet, so Settings still shows
+// Ethereum Mainnet. The user taps "Save" there. The URL is for Ethereum
+// Mainnet, so the save stores the URL for neither network.
+test.each([
+    { button: "btn-save-rpc", field: "settings-rpc" },
+    { button: "btn-save-blockscout", field: "settings-blockscout" },
+])(
+    "$button saves nothing when tapped while the follow's write waits",
+    async ({ button, field }) => {
+        const page = await bootOnAddress();
+        await page.click("btn-settings");
+        // This answer passes both endpoint checks on Ethereum Mainnet.
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ result: NETWORKS.mainnet.chainId }),
+        });
+        const url = "https://own-node.example.invalid";
+
+        const { set } = page.storage.local;
+        const write = set.getMockImplementation();
+        let releaseWrite;
+        const writeHeld = new Promise((resolve) => {
+            releaseWrite = resolve;
+        });
+        // The background's write lands; the next, the follow's, waits.
+        set.mockImplementationOnce(write).mockImplementationOnce(
+            async (items) => {
+                await writeHeld;
+                await write(items);
+            },
+        );
+        await backgroundSwitch(page, "sepolia");
+        const { state } = require("../src/shared/state");
+        expect(state.networkId).toBe("sepolia");
+        expect(page.value("settings-network")).toBe("mainnet");
+
+        page.node(field).value = url;
+        const saving = page.node(button).listeners.click.map((fn) => fn());
+        await page.settle();
+        releaseWrite();
+        await Promise.all(saving);
+        await page.settle();
+
+        expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(
+            url,
+        );
+        expect(page.text("flash-msg")).toBe(
+            "The URL was not saved because the network changed.",
+        );
+    },
+);
+
+// The user taps the RPC "Save" on Ethereum Mainnet. While the check waits for
+// the node's answer, the popup follows the background's switch to Sepolia. The
+// node answers with Sepolia's chain id. So the check refuses the node for
+// Ethereum Mainnet, and nothing is stored.
+test("the RPC check compares the answer with the network at the tap", async () => {
+    const page = await bootOnAddress();
+    await page.click("btn-settings");
+    let answer;
+    globalThis.fetch.mockReturnValue(
+        new Promise((resolve) => {
+            answer = resolve;
+        }),
+    );
+    const url = "https://sepolia-node.example.invalid";
+
+    page.node("settings-rpc").value = url;
+    const saving = page.node("btn-save-rpc").listeners.click.map((fn) => fn());
+    await page.settle();
+    await backgroundSwitch(page, "sepolia");
+    const { state } = require("../src/shared/state");
+    expect(state.networkId).toBe("sepolia");
+    answer({ json: async () => ({ result: NETWORKS.sepolia.chainId }) });
+    await Promise.all(saving);
+    await page.settle();
+
+    expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(url);
+    expect(page.text("flash-msg")).toBe(
+        "Wrong network: expected Ethereum Mainnet.",
+    );
+});
+
+// The user taps the Blockscout "Save" on Ethereum Mainnet. While the check
+// waits for Blockscout's answer, the popup follows the background's switch to
+// Sepolia. The URL is for Ethereum Mainnet, so nothing is stored.
+test("the Blockscout save is for the network at the tap", async () => {
+    const page = await bootOnAddress();
+    await page.click("btn-settings");
+    let answer;
+    globalThis.fetch.mockReturnValue(
+        new Promise((resolve) => {
+            answer = resolve;
+        }),
+    );
+    const url = "https://own-explorer.example.invalid/api/v2";
+
+    page.node("settings-blockscout").value = url;
+    const saving = page
+        .node("btn-save-blockscout")
+        .listeners.click.map((fn) => fn());
+    await page.settle();
+    await backgroundSwitch(page, "sepolia");
+    expect(page.value("settings-network")).toBe("sepolia");
+    answer({ ok: true });
+    await Promise.all(saving);
+    await page.settle();
+
+    expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(url);
+    expect(page.text("flash-msg")).toBe(
+        "The URL was not saved because the network changed.",
+    );
+});
+
+// Settings is open when the network changes to Sepolia. The popup follows the
+// background's switch, or the user picks Sepolia in the network selector. Each
+// "Save" after the switch stores its URL for Sepolia.
+test.each([
+    ["a follow", (page) => backgroundSwitch(page, "sepolia")],
+    [
+        "the network selector",
+        async (page) => {
+            const select = page.node("settings-network");
+            select.value = "sepolia";
+            for (const fn of select.listeners.change) await fn();
+            await page.settle();
+        },
+    ],
+])(
+    "after a switch to Sepolia by %s, Settings saves each URL for Sepolia",
+    async (_how, switchToSepolia) => {
+        const page = await bootOnAddress();
+        await page.click("btn-settings");
+        await switchToSepolia(page);
+        // This answer passes both endpoint checks on Sepolia. The RPC check
+        // reads Sepolia's chain id from it. The Blockscout check reads `ok`.
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ result: NETWORKS.sepolia.chainId }),
+        });
+        const rpcUrl = "https://own-node.example.invalid";
+        const blockscoutUrl = "https://own-explorer.example.invalid/api/v2";
+
+        page.node("settings-rpc").value = rpcUrl;
+        await page.click("btn-save-rpc");
+        expect(page.text("flash-msg")).toBe("Saved.");
+        page.node("settings-blockscout").value = blockscoutUrl;
+        await page.click("btn-save-blockscout");
+        expect(page.text("flash-msg")).toBe("Saved.");
+
+        const stored = page.storage.read("autistmask");
+        expect(stored.networkId).toBe("sepolia");
+        expect(stored.rpcUrl).toBe(rpcUrl);
+        expect(stored.blockscoutUrl).toBe(blockscoutUrl);
+    },
+);
+
+// The user picks Sepolia in Settings, but the switch's write fails. The page is
+// then on Sepolia, while Settings was last drawn for Ethereum Mainnet. A "Save"
+// after the failed switch stores nothing for either network.
+test.each([
+    { button: "btn-save-rpc", field: "settings-rpc" },
+    { button: "btn-save-blockscout", field: "settings-blockscout" },
+])(
+    "$button saves nothing after a switch in Settings whose write failed",
+    async ({ button, field }) => {
+        const page = await bootOnAddress();
+        await page.click("btn-settings");
+        page.storage.local.set.mockRejectedValueOnce(
+            new Error("quota exceeded"),
+        );
+        const select = page.node("settings-network");
+        select.value = "sepolia";
+        for (const fn of select.listeners.change) {
+            await expect(fn()).rejects.toThrow("quota exceeded");
+        }
+        await page.settle();
+        const { state } = require("../src/shared/state");
+        expect(state.networkId).toBe("sepolia");
+        // This answer passes both endpoint checks on Ethereum Mainnet.
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ result: NETWORKS.mainnet.chainId }),
+        });
+        const url = "https://own-node.example.invalid";
+
+        page.node(field).value = url;
+        await page.click(button);
+
+        expect(JSON.stringify(page.storage.read("autistmask"))).not.toContain(
+            url,
+        );
+        expect(page.text("flash-msg")).toBe(
+            "The URL was not saved because the network changed.",
+        );
+    },
+);
+
 // 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/trackedTokensPerNetwork.test.js

@@ -177,6 +177,78 @@ test("a token added by contract address on Sepolia is tracked on Sepolia only",
     expect(onSepolia).not.toContain("DAI");
 });
 
+// Another popup page tracks DAI on Ethereum Mainnet after this page's last
+// save. The switch's save writes only the token lists that this page changed.
+// So DAI stays in `trackedTokens`, the active network's list.
+test("a token another page tracked before a switch in Settings stays in trackedTokens", async () => {
+    const boot = await bootPopup(unversionedValidProfile());
+    expect(boot.pageErrors).toEqual([]);
+    boot.storage.write("autistmask", {
+        ...boot.storage.read("autistmask"),
+        trackedTokens: [MAINNET_TOKEN],
+    });
+
+    await boot.click("btn-settings");
+    await chooseNetwork(boot, "sepolia");
+
+    const stored = boot.storage.read("autistmask");
+    expect(stored.networkId).toBe("sepolia");
+    expect(stored.trackedTokens).toEqual([MAINNET_TOKEN]);
+    expect(stored.networkTrackedTokens.mainnet).toEqual([]);
+});
+
+// The contract lookup on SettingsAddToken answers on Ethereum Mainnet while the
+// switch to Sepolia waits for the lock. The page adds the token to Ethereum
+// Mainnet's list. The switch then keeps that list for Ethereum Mainnet.
+test("a token added while a switch in Settings waits for the lock stays tracked on Ethereum Mainnet", async () => {
+    const boot = await bootOnAddToken("mainnet");
+    expect(boot.pageErrors).toEqual([]);
+    const { lookupTokenInfo } = require("../src/shared/balances");
+    let answer;
+    lookupTokenInfo.mockImplementationOnce(
+        () =>
+            new Promise((resolve) => {
+                answer = resolve;
+            }),
+    );
+    boot.node("settings-addtoken-address").value = NEW_TOKEN_ADDRESS;
+    const adding = boot.click("btn-settings-addtoken-manual");
+    await boot.click("btn-settings");
+
+    // Another write holds the lock, so the switch's save waits for it.
+    let releaseLock;
+    const lockHeld = navigator.locks.request(
+        "autistmask",
+        () =>
+            new Promise((resolve) => {
+                releaseLock = resolve;
+            }),
+    );
+    const select = boot.node("settings-network");
+    select.value = "sepolia";
+    const switching = Promise.all(select.listeners.change.map((fn) => fn()));
+    await boot.settle();
+
+    answer({ symbol: "NEW", decimals: 18, name: "New Token" });
+    await boot.settle();
+    releaseLock();
+    await lockHeld;
+    await switching;
+    await adding;
+
+    const stored = boot.storage.read("autistmask");
+    expect(stored.networkId).toBe("sepolia");
+    expect(stored.trackedTokens).toEqual([]);
+    expect(stored.networkTrackedTokens.mainnet).toEqual([
+        {
+            address: NEW_TOKEN_ADDRESS,
+            symbol: "NEW",
+            decimals: 18,
+            name: "New Token",
+        },
+    ]);
+});
+
 describe("Back after a switch from the Settings gear", () => {
     test("SettingsAddToken no longer offers the common tokens", async () => {
         const boot = await bootOnAddToken("mainnet");

tests/uniswap.test.js

@@ -2871,8 +2871,9 @@ describe("uniswap decoder", () => {
                         ...USDT_400_GROUP,
                         ...ONE_USDT_LINES(OTHER_ADDR),
                     ],
-                    // The last swap step's minimum.
-                    minimum: "390.0000 USDC",
+                    // Both swap steps pay USDC to the user, so the minimum
+                    // is the sum of their two minimums.
+                    minimum: "980.0000 USDC",
                 },
             ])(
                 "$kind shows each take's own lines and the allowances, and no Amount figure or Min. received",
@@ -3440,6 +3441,82 @@ describe("uniswap decoder", () => {
             });
         });
 
+        // https://git.eeqj.de/sneak/AutistMask/issues/685 — Permit2 moves no
+        // ETH, so a PERMIT2_TRANSFER_FROM of the zero address reads as a move
+        // of a token nothing knows. On next at ec6b6b5 its lines read ETH,
+        // with an ETH figure.
+        describe("a PERMIT2_TRANSFER_FROM of the zero address", () => {
+            const MOVED_AMOUNT =
+                "1000000000000000000 base units (decimals unknown)";
+
+            test("to another address names the address", () => {
+                const result = decodeSteps(
+                    [0x00, 0x02],
+                    [V3_600, transfer(ZERO_ADDR, OTHER_ADDR, ONE_WETH)],
+                );
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "600.0000 USDT"],
+                    ["Moved from the sender", MOVED_AMOUNT],
+                    ["Token moved", ZERO_ADDR],
+                    ["Moved to", OTHER_ADDR],
+                ]);
+                expect(detail(result, "Token moved").address).toBe(ZERO_ADDR);
+            });
+
+            test("into the router names the address", () => {
+                const result = decodeSteps(
+                    [0x02, 0x00],
+                    [transfer(ZERO_ADDR, ROUTER_ADDR, ONE_WETH), V3_600],
+                );
+                expect(detail(result, "Paid to").value).toBe(
+                    "The router, " +
+                        MOVED_AMOUNT +
+                        " from the sender (later steps may not spend all of it)",
+                );
+                expect(detail(result, "Token moved into the router")).toEqual({
+                    label: "Token moved into the router",
+                    value: ZERO_ADDR,
+                    address: ZERO_ADDR,
+                    isToken: true,
+                });
+            });
+
+            // The V4 step's SETTLE names the user as payer and states no
+            // amount. The step's lines say that the ETH amount is not known.
+            test("after a V4 exact-out step of ETH, also shows that the ETH amount is not known", () => {
+                const v4EthExactOut = encodeV4Swap(
+                    new Uint8Array([
+                        V4_SWAP_EXACT_OUT_SINGLE_ID,
+                        V4_SETTLE_ID,
+                        V4_TAKE_ALL_ID,
+                    ]),
+                    [
+                        encodeV4ExactOutSingle(
+                            ZERO_ADDR,
+                            USDC_ADDR,
+                            590000000n,
+                            ONE_WETH,
+                        ),
+                        encodeV4Settle(ZERO_ADDR),
+                        encodeV4TakeAll(USDC_ADDR, 0n),
+                    ],
+                );
+                const result = decodeSteps(
+                    [0x10, 0x02],
+                    [v4EthExactOut, transfer(ZERO_ADDR, OTHER_ADDR, ONE_WETH)],
+                );
+                expect(detail(result, "Token In").value).toBe("ETH (native)");
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Moved from the sender", UNDECODED],
+                    ["Token moved", "ETH"],
+                    ["Moved to", "The swap step that spends it"],
+                    ["Moved from the sender", MOVED_AMOUNT],
+                    ["Token moved", ZERO_ADDR],
+                    ["Moved to", OTHER_ADDR],
+                ]);
+            });
+        });
+
         // https://git.eeqj.de/sneak/AutistMask/issues/682 — V4 pays a SETTLE
         // of ETH from the router's own ETH, whichever payer the SETTLE names,
         // and the router holds the transaction's value. On next at 36b2002 a
@@ -3562,6 +3639,355 @@ describe("uniswap decoder", () => {
                 ]);
             });
         });
+
+        // https://git.eeqj.de/sneak/AutistMask/issues/647 — on next at
+        // f550d8c, a split whose steps each pay WETH to the user showed only
+        // the last step's minimum.
+        describe("the minimum of a split that pays WETH to the user", () => {
+            const WETH_01 = 100000000000000000n;
+            const WETH_02 = 200000000000000000n;
+            const WETH_03 = 300000000000000000n;
+            // A V3 exact-in of 600 USDT for at least 0.3 WETH, and a V2
+            // exact-in of 400 USDT for at least 0.2 WETH, each paid to the
+            // user.
+            const V3_TO_WETH = encodeV3SwapExactIn(
+                USER_ADDR,
+                USDT_600,
+                WETH_03,
+                [USDT_ADDR, WETH_ADDR],
+            );
+            const V2_TO_WETH = encodeV2SwapExactIn(
+                USER_ADDR,
+                USDT_400,
+                WETH_02,
+                [USDT_ADDR, WETH_ADDR],
+            );
+            // A V4 step that swaps 400 USDT for at least 0.2 WETH, with these
+            // TAKEs of the WETH.
+            const v4ToWeth = (...takes) =>
+                encodeV4Swap(
+                    new Uint8Array([
+                        V4_SWAP_EXACT_IN_SINGLE_ID,
+                        V4_SETTLE_ID,
+                        ...takes.map(() => V4_TAKE_ID),
+                    ]),
+                    [
+                        encodeV4ExactInSingle(
+                            USDT_ADDR,
+                            WETH_ADDR,
+                            USDT_400,
+                            WETH_02,
+                        ),
+                        encodeV4Settle(USDT_ADDR), // paid by the user
+                        ...takes,
+                    ],
+                );
+            // The swap's minimum line as [label, value], or undefined.
+            const minimum = (result) =>
+                result.details
+                    .filter(
+                        (d) =>
+                            d.label === "Min. received" ||
+                            d.label === "Min. paid out",
+                    )
+                    .map((d) => [d.label, d.value])[0];
+
+            test("a V3 and a V2 exact-in show the total of their minimums", () => {
+                const result = decodeSteps(
+                    [0x00, 0x08],
+                    [V3_TO_WETH, V2_TO_WETH],
+                );
+                expect(minimum(result)).toEqual([
+                    "Min. received",
+                    "0.5000 WETH",
+                ]);
+            });
+
+            test("a V3 exact-in and a V4 step show the total of their minimums", () => {
+                const result = decodeSteps(
+                    [0x00, 0x10],
+                    [V3_TO_WETH, v4ToWeth(encodeV4Take(WETH_ADDR))],
+                );
+                expect(minimum(result)).toEqual([
+                    "Min. received",
+                    "0.5000 WETH",
+                ]);
+            });
+
+            // The second route buys DAI for the router, then swaps all of it
+            // from the router for at least 0.2 WETH.
+            test("a route that hops through DAI counts its last hop's minimum", () => {
+                const result = decodeSteps(
+                    [0x00, 0x08, 0x00],
+                    [
+                        V3_TO_WETH,
+                        encodeV2SwapExactIn(ROUTER_ADDR, USDT_400, DAI_400, [
+                            USDT_ADDR,
+                            DAI_ADDR,
+                        ]),
+                        coder.encode(
+                            ["address", "uint256", "uint256", "bytes", "bool"],
+                            [
+                                USER_ADDR,
+                                2n ** 255n, // CONTRACT_BALANCE
+                                WETH_02,
+                                encodeV3Path([DAI_ADDR, WETH_ADDR]),
+                                false, // paid from the router
+                            ],
+                        ),
+                    ],
+                );
+                expect(minimum(result)).toEqual([
+                    "Min. received",
+                    "0.5000 WETH",
+                ]);
+            });
+
+            // The middle step swaps 0.3 of the user's WETH for USDC, so the
+            // sum of minimums starts again after it.
+            test.each([
+                {
+                    kind: "a V3 exact-in",
+                    command: 0x00,
+                    input: encodeV3SwapExactIn(USER_ADDR, WETH_03, 1n, [
+                        WETH_ADDR,
+                        USDC_ADDR,
+                    ]),
+                },
+                {
+                    kind: "a V2 exact-in",
+                    command: 0x08,
+                    input: encodeV2SwapExactIn(USER_ADDR, WETH_03, 1n, [
+                        WETH_ADDR,
+                        USDC_ADDR,
+                    ]),
+                },
+                {
+                    kind: "a V2 exact-out",
+                    command: 0x09,
+                    input: encodeV2SwapExactOut(USER_ADDR, 1n, WETH_03, [
+                        WETH_ADDR,
+                        USDC_ADDR,
+                    ]),
+                },
+                {
+                    kind: "a V3 exact-out",
+                    command: 0x01,
+                    input: encodeV3SwapExactOut(USER_ADDR, 1n, WETH_03, [
+                        USDC_ADDR,
+                        WETH_ADDR,
+                    ]),
+                },
+            ])(
+                "$kind that spends WETH between them leaves the last step's minimum",
+                ({ command, input }) => {
+                    const result = decodeSteps(
+                        [0x00, command, 0x08],
+                        [V3_TO_WETH, input, V2_TO_WETH],
+                    );
+                    expect(minimum(result)).toEqual([
+                        "Min. received",
+                        "0.2000 WETH",
+                    ]);
+                },
+            );
+
+            // The middle step swaps 0.3 WETH and 400 DAI for USDC, both paid
+            // by the user. It spends WETH whichever SETTLE comes last.
+            test.each([
+                { order: "WETH first", settled: [WETH_ADDR, DAI_ADDR] },
+                { order: "DAI first", settled: [DAI_ADDR, WETH_ADDR] },
+            ])(
+                "a V4 step that spends WETH and DAI between them leaves the last step's minimum, with the SETTLE of $order",
+                ({ settled }) => {
+                    const wethAndDaiForUsdc = encodeV4Swap(
+                        new Uint8Array([
+                            V4_SWAP_EXACT_IN_SINGLE_ID,
+                            V4_SWAP_EXACT_IN_SINGLE_ID,
+                            V4_SETTLE_ID,
+                            V4_SETTLE_ID,
+                            V4_TAKE_ALL_ID,
+                        ]),
+                        [
+                            encodeV4ExactInSingle(
+                                WETH_ADDR,
+                                USDC_ADDR,
+                                WETH_03,
+                                1n,
+                            ),
+                            encodeV4ExactInSingle(
+                                DAI_ADDR,
+                                USDC_ADDR,
+                                DAI_400,
+                                1n,
+                            ),
+                            ...settled.map((token) => encodeV4Settle(token)),
+                            encodeV4TakeAll(USDC_ADDR, 0n),
+                        ],
+                    );
+                    const result = decodeSteps(
+                        [0x00, 0x10, 0x08],
+                        [V3_TO_WETH, wethAndDaiForUsdc, V2_TO_WETH],
+                    );
+                    expect(minimum(result)).toEqual([
+                        "Min. received",
+                        "0.2000 WETH",
+                    ]);
+                },
+            );
+
+            // The middle step's swap actions buy WETH with the user's USDT,
+            // then swap all of that WETH for USDC.
+            test("a V4 step that swaps through WETH between them leaves the last step's minimum", () => {
+                const usdtToUsdcThroughWeth = encodeV4Swap(
+                    new Uint8Array([
+                        V4_SWAP_EXACT_IN_SINGLE_ID,
+                        V4_SWAP_EXACT_IN_SINGLE_ID,
+                        V4_SETTLE_ID,
+                        V4_TAKE_ALL_ID,
+                    ]),
+                    [
+                        encodeV4ExactInSingle(
+                            USDT_ADDR,
+                            WETH_ADDR,
+                            USDT_400,
+                            WETH_01,
+                        ),
+                        encodeV4ExactInSingle(WETH_ADDR, USDC_ADDR, 0n, 1n),
+                        encodeV4Settle(USDT_ADDR), // paid by the user
+                        encodeV4TakeAll(USDC_ADDR, 0n),
+                    ],
+                );
+                const result = decodeSteps(
+                    [0x00, 0x10, 0x08],
+                    [V3_TO_WETH, usdtToUsdcThroughWeth, V2_TO_WETH],
+                );
+                expect(minimum(result)).toEqual([
+                    "Min. received",
+                    "0.2000 WETH",
+                ]);
+            });
+
+            // The middle step has no swap action. Its SETTLE or SETTLE_ALL
+            // pays 0.3 WETH, and its TAKE pays that WETH to another address.
+            test.each([
+                {
+                    payment: "a SETTLE of WETH paid by the user",
+                    actions: [V4_SETTLE_ID, V4_TAKE_ID],
+                    params: [
+                        settle(WETH_ADDR, WETH_03, true),
+                        take(WETH_ADDR, OTHER_ADDR, 0n),
+                    ],
+                },
+                {
+                    payment: "a SETTLE of WETH paid from the router",
+                    actions: [V4_SETTLE_ID, V4_TAKE_ID],
+                    params: [
+                        settle(WETH_ADDR, WETH_03, false),
+                        take(WETH_ADDR, OTHER_ADDR, 0n),
+                    ],
+                },
+                {
+                    payment: "a SETTLE_ALL of WETH",
+                    actions: [V4_TAKE_ID, V4_SETTLE_ALL_ID],
+                    params: [
+                        take(WETH_ADDR, OTHER_ADDR, WETH_03),
+                        encodeV4SettleAll(WETH_ADDR, WETH_03),
+                    ],
+                },
+            ])(
+                "a V4 step with $payment between them leaves the last step's minimum",
+                ({ actions, params }) => {
+                    const wethToOther = encodeV4Swap(
+                        new Uint8Array(actions),
+                        params,
+                    );
+                    const result = decodeSteps(
+                        [0x00, 0x10, 0x08],
+                        [V3_TO_WETH, wethToOther, V2_TO_WETH],
+                    );
+                    expect(minimum(result)).toEqual([
+                        "Min. paid out",
+                        "0.2000 WETH",
+                    ]);
+                },
+            );
+
+            test("a PERMIT2_TRANSFER_FROM of WETH between them leaves the last step's minimum", () => {
+                const result = decodeSteps(
+                    [0x00, 0x02, 0x08],
+                    [
+                        V3_TO_WETH,
+                        permit2TransferFrom(WETH_ADDR, OTHER_ADDR, WETH_03),
+                        V2_TO_WETH,
+                    ],
+                );
+                expect(minimum(result)).toEqual([
+                    "Min. paid out",
+                    "0.2000 WETH",
+                ]);
+            });
+
+            // The decoder reads no minimum from a V4 exact-out action.
+            test("a step that states no minimum leaves no figure", () => {
+                const exactOut = encodeV4Swap(
+                    new Uint8Array([
+                        V4_SWAP_EXACT_OUT_SINGLE_ID,
+                        V4_SETTLE_ALL_ID,
+                        V4_TAKE_ALL_ID,
+                    ]),
+                    [
+                        encodeV4ExactOutSingle(
+                            USDT_ADDR,
+                            WETH_ADDR,
+                            WETH_02,
+                            USDT_400,
+                        ),
+                        encodeV4SettleAll(USDT_ADDR, USDT_400),
+                        encodeV4TakeAll(WETH_ADDR, 0n),
+                    ],
+                );
+                const result = decodeSteps(
+                    [0x10, 0x00],
+                    [exactOut, V3_TO_WETH],
+                );
+                expect(minimum(result)).toBeUndefined();
+            });
+
+            test("a step that pays some of its WETH to the router leaves no figure", () => {
+                const result = decodeSteps(
+                    [0x00, 0x10],
+                    [
+                        V3_TO_WETH,
+                        v4ToWeth(
+                            take(WETH_ADDR, USER_ADDR, WETH_01),
+                            take(WETH_ADDR, ROUTER_ADDR, 0n),
+                        ),
+                    ],
+                );
+                expect(minimum(result)).toBeUndefined();
+            });
+
+            // The router still runs a swap step whose recipient cannot be
+            // read, and that step may spend the WETH the first step paid.
+            test("a step between them that cannot be read leaves no figure", () => {
+                const result = decodeSteps(
+                    [0x00, 0x00, 0x08],
+                    [
+                        V3_TO_WETH,
+                        dirtyWord(
+                            encodeV3SwapExactIn(USER_ADDR, WETH_03, 1n, [
+                                WETH_ADDR,
+                                USDC_ADDR,
+                            ]),
+                            0,
+                        ),
+                        V2_TO_WETH,
+                    ],
+                );
+                expect(minimum(result)).toBeUndefined();
+            });
+        });
     });
 
     // https://git.eeqj.de/sneak/AutistMask/issues/359 — the output half, in
@@ -4304,10 +4730,9 @@ describe("uniswap decoder", () => {
         expect(detail(result, "Min. received").value).toBe("2.0000 USDC");
     });
 
-    // With no minimum stated before it, a zero balance check is what sets the
-    // output side, and it guarantees nothing. No step pays anyone, so the
-    // minimum is not said to be received.
-    test("a zero balance check with no earlier minimum states no minimum", () => {
+    // A zero balance check sets neither Token Out nor the minimum. The route
+    // pays only the WRAP_ETH's WETH, to the router, where it stays.
+    test("a zero balance check after a WRAP_ETH into the router names no output token and no minimum", () => {
         const data = buildExecute(
             solidityPacked(["uint8", "uint8"], [0x0b, 0x0e]),
             [
@@ -4320,9 +4745,16 @@ describe("uniswap decoder", () => {
         const result = uniswap.decode(data, ROUTER_ADDR, "0x1", {}, USER_ADDR);
         expect(result).not.toBeNull();
 
-        expect(detail(result, "Token Out").value).toContain("USDT");
-        expect(detail(result, "Min. paid out").value).toBe(
-            "None (no minimum guaranteed)",
+        expect(detail(result, "Token Out").value).toBe(
+            "Unknown (not named in the calldata)",
+        );
+        expect(detail(result, "Min. paid out")).toBeUndefined();
+        expect(detail(result, "Min. received")).toBeUndefined();
+        expect(detail(result, "Paid to").value).toBe(
+            "The router, where it stays (no later step pays it out)",
+        );
+        expect(detail(result, "Token moved into the router").address).toBe(
+            WETH_ADDR,
         );
     });
 

tests/uniswapRecipient.test.js

@@ -688,6 +688,62 @@ describe("an UNWRAP_WETH makes the output ETH only when the router holds it", ()
         ]);
     });
 
+    // The same route, then a balance check of the sender's USDC with a zero
+    // minimum. The check guarantees nothing, so Token Out stays ETH
+    // (https://git.eeqj.de/sneak/AutistMask/issues/649).
+    test("the same route, then a zero balance check of USDC, still reads as ETH with no minimum", () => {
+        const result = decode(
+            execute(
+                v4Swap(
+                    SWAP_USDT_FOR_WETH,
+                    SETTLE_USDT,
+                    take(WETH, MSG_SENDER, (ONE_WETH * 6n) / 10n),
+                    take(WETH, ADDRESS_THIS),
+                ),
+                unwrapWeth(MSG_SENDER),
+                balanceCheck(USDC, 0n),
+            ),
+        );
+        expect(result.name).toBe("Swap USDT → ETH");
+        expect(detail(result, "Token Out").value).toBe("ETH");
+        expect(labels(result)).toEqual([
+            "Protocol",
+            "Token In",
+            "Amount",
+            "Token Out",
+            "Steps",
+            "Deadline",
+        ]);
+    });
+
+    // A PERMIT2_TRANSFER_FROM moves the sender's WETH into the router. An
+    // UNWRAP_WETH pays that WETH to the user as ETH. A zero balance check of
+    // USDC sets neither Token Out nor the minimum, before the UNWRAP_WETH or
+    // after it (https://git.eeqj.de/sneak/AutistMask/issues/649).
+    test.each([
+        {
+            kind: "before the UNWRAP_WETH",
+            steps: [balanceCheck(USDC, 0n), unwrapWeth(MSG_SENDER)],
+        },
+        {
+            kind: "after the UNWRAP_WETH",
+            steps: [unwrapWeth(MSG_SENDER), balanceCheck(USDC, 0n)],
+        },
+    ])(
+        "WETH moved into the router and unwrapped, with a zero balance check of USDC $kind, reads as ETH with no minimum",
+        ({ steps }) => {
+            const result = decode(
+                execute(
+                    permit2TransferFrom(WETH, ADDRESS_THIS, ONE_WETH),
+                    ...steps,
+                ),
+            );
+            expect(detail(result, "Token Out").value).toBe("ETH");
+            expect(detail(result, "Min. received")).toBeUndefined();
+            expect(detail(result, "Min. paid out")).toBeUndefined();
+        },
+    );
+
     // A TAKE the decoder cannot read may pay part of the WETH to the user.
     test("one V4 step paying WETH to the router beside a TAKE that cannot be read, then an UNWRAP_WETH, reads as ETH with no minimum", () => {
         const result = decode(
@@ -2820,17 +2876,16 @@ describe("the allow-revert flag", () => {
         },
     );
 
-    test("a BALANCE_CHECK_ERC20 with the flag, and no minimum before it, states none", () => {
+    test("a BALANCE_CHECK_ERC20 with the flag, and no minimum before it, names no output token and no minimum", () => {
         const check = balanceCheck(WETH, ONE_WETH);
         expect(detail(decode(execute(check)), "Min. paid out").value).toBe(
             "1.0000 WETH",
         );
 
         const withFlag = decode(execute(flagged(check)));
-        expect(detail(withFlag, "Token Out").address).toBe(WETH);
-        expect(detail(withFlag, "Min. paid out").value).toBe(
-            "None (no minimum guaranteed)",
-        );
+        expect(detail(withFlag, "Token Out").value).toBe(UNNAMED);
+        expect(detail(withFlag, "Min. paid out")).toBeUndefined();
+        expect(detail(withFlag, "Min. received")).toBeUndefined();
     });
 
     // Only the routers from UniversalRouterV2 on let a PERMIT2_PERMIT fail.