fix: tracked tokens' balances are read through the RPC endpoint (closes #669)

refreshBalances() now reads the balance of every token tracked on the
active network, at every address, with balanceOf through the same
provider as the ETH balance. The entry takes its holder count and
decimals from Blockscout's entry for the token in the same refresh, or
keeps them from before while Blockscout fails. A failed balanceOf keeps
the token's previous entry, or takes Blockscout's entry when there is
none, and is logged. Blockscout's answer still adds the tokens the user
has not tracked, as before.

The browser test for a hostile symbol now untracks the stub token
first, because a tracked token is listed under the symbol it was added
with.

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 + ERC-20 balance fetching via RPC + Blockscout
+    balances.js       — ETH and tracked token balances via RPC, others via 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, see Transaction Decoding), do not always read as a
+only the user is paid and no allowance goes to a spender other than the router,
-number. They can read:
+see Transaction Decoding), do not always read as a 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,7 +1243,11 @@ 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.
+   actions that buy the output currency, except that the step gives none when a
+   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
@@ -1375,23 +1379,30 @@ 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 by `fetchTokenBalances()` in
+Which tokens an address shows is decided on every refresh by `refreshBalances()`
-`src/shared/balances.js`, from the Blockscout `token-balances` response, so
+in `src/shared/balances.js`. The balance of each token tracked on the active
-tokens do appear without the user adding them. An ERC-20 is shown when its
+network is read with `balanceOf` through the RPC endpoint, for every address.
-balance is nonzero and it is in the bundled known-token list, is tracked by the
+Its holder count and `decimals` are those of Blockscout's entry for it in the
-user, or has 1,000 or more holders; a token claiming a symbol from the bundled
+same refresh, kept from before while Blockscout fails. A read that fails keeps
-list from any other contract address is always dropped, and so is any token
+that token's previous entry, as a failed ETH balance keeps its figure, or takes
-claiming a symbol that belongs to the native asset and therefore has no
+Blockscout's entry from the same refresh when there is none. Every other token
-legitimate contract at all (`"ETH"`, and every network's `nativeCurrency`, such
+comes from the Blockscout `token-balances` response (`fetchTokenBalances()`), so
-as `"SepoliaETH"`, on every network). That filter is unconditional — the "Hide
+tokens do appear without the user adding them, and they keep their previous
-tokens with fewer than 1,000 holders" setting governs the transaction history
+figures while Blockscout fails. A tracked token is shown when its balance is
-and the send-screen token selector, not this list. A token's holder count is
+nonzero, and any other ERC-20 when its balance is nonzero and it is in the
-unknown when the explorer reports none, or reports anything other than a whole
+bundled known-token list or has 1,000 or more holders. A token claiming a symbol
-number written in digits alone, such as `1,000` or `1e3` (`parseHoldersCount()`
+from the bundled list from any other contract address is always dropped, tracked
-in `src/shared/holders.js`). This list does not take an unknown count as 1,000
+or not, and so is any token claiming a symbol that belongs to the native asset
-or more, so such a token is shown only when it is on the bundled list or
+and therefore has no legitimate contract at all (`"ETH"`, and every network's
-tracked. `fetchTokenBalances()` stores every nonzero holding of a token it
+`nativeCurrency`, such as `"SepoliaETH"`, on every network). That filter is
-admits, however small, but a holding below 0.000001 is left out of the balance
+unconditional — the "Hide tokens with fewer than 1,000 holders" setting governs
+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
@@ -2658,7 +2669,8 @@ 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`),
+  balances (`eth_getBalance`), read ERC-20 token contracts (`eth_call`), among
+  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
@@ -3197,8 +3209,9 @@ 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) and no `Paid to` line is shown. `Paid to` lines after
+  TransactionDetail), no `Paid to` line is shown, and no permit or batch grants
-  `Token Out` name each other address paid; one reads
+  an allowance to a spender other than the router (see below). `Paid to` lines
+  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)`
@@ -3252,7 +3265,8 @@ Currently supported:
   (listed at the end of this section), a step whose input it cannot read, in
   whole or in part, and a step it fails on. Every other `PERMIT2_PERMIT`, before
   the step that sets the input side or after it, leaves `Token In` and the
-  `Amount` line as they read with no permit: a permit of 5,000 DAI to another
+  `Amount` line as they read with no permit, unless it lets a spender other than
+  the router take `Token In` (see below): a permit of 5,000 DAI to another
   address and then a V3 exact-in of 600 USDT read `Swap USDT → USDC` with
   `Amount 600.0000 USDT`, and so do that exact-in and then a permit of 5,000 DAI
   to the router. When a permit's amount stands and the step that sets the input
@@ -3263,15 +3277,25 @@ Currently supported:
   of a token other than `Token In`; one of `Token In` after an amount that is
   not a quantity (a V4 open delta, `ALREADY_PAID`, which keep their wording on
   the `Amount` line, or no stated amount, as of a V4 exact-out step); and one
-  whose amount the decoder does not know. When the step that sets the input side
+  whose amount the decoder does not know. When there is no `Amount` line, each
-  states no amount, the user pays it some of its input token, and there is no
+  take the total counts gets them too, so that every amount the decoder reads is
-  `Amount` line, that step gets them too whenever another take's lines give a
+  shown: the amount the step that sets the input side states, when it is a
-  figure, or a `PERMIT2_TRANSFER_FROM` of its token gives one, on the lines
+  quantity and the user pays that step (a V2 or V3 step whose `payerIsUser` is
-  below or, into the router, on its `Paid to` line, so that figure cannot read
+  true, a V4 step the user pays some of its input token, or a `WRAP_ETH`, whose
-  as all that leaves. When it states no amount and the user pays it none of its
+  ETH comes from the transaction's value), and each later take of `Token In`
-  input token, as when the router pays it, that step takes none of that token
+  added to it. A step that sets the input side and is paid from the router takes
-  from the user's wallet and never gets them, with a permit or without. They
+  nothing from the user's wallet and gets none. A `PERMIT2_PERMIT` the decoder
-  come in step order, the step that sets the input side first when it has them:
+  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
@@ -3309,19 +3333,26 @@ Currently supported:
   `PERMIT2_PERMIT` or `PERMIT2_PERMIT_BATCH` whose input the decoder cannot
   read, such as one whose token or spender word has a nonzero top byte, may let
   any spender take any amount of any token: it gives one `Permit2 allowance`
-  line alone, reading `Unknown (could not be decoded)`, and leaves no `Amount`
+  line alone, reading `Unknown (could not be decoded)`. These lines change no
-  line, whose figure might be too low. These lines change neither the `Paid to`
+  `Paid to` line: a permit or batch pays nobody. But code that a step runs, such
-  lines nor the minimum's label: a permit or batch pays nobody. A step goes
+  as a V4 pool's hook or a token's own code, can call a spender other than the
-  unread when its recipient does not decode as an address, when it is a V3 swap
+  router, which can then take up to its allowance from the user's wallet before
-  step whose path is shorter than one token address or has bytes after its last
+  the transaction ends. So an allowance to any spender but the router, or a
-  hop, or when it is a command the decoder does not read: every command other
+  permit or batch the decoder cannot read, makes the minimum read
-  than `PERMIT2_PERMIT`, `PERMIT2_PERMIT_BATCH`, `PERMIT2_TRANSFER_FROM`,
+  `Min. paid out`, and when its token is `Token In`, or the decoder does not
-  `V2_SWAP_EXACT_IN`, `V2_SWAP_EXACT_OUT`, `V3_SWAP_EXACT_IN`,
+  know its token or `Token In`, it leaves no `Amount` line, whose figure might
-  `V3_SWAP_EXACT_OUT`, `V4_SWAP`, `SWEEP`, `TRANSFER`, `PAY_PORTION`,
+  be too low: a permit of 5,000 USDT to another address and then a V3 exact-in
-  `PAY_PORTION_FULL_PRECISION`, `ACROSS_V4_DEPOSIT_V3`, `WRAP_ETH`,
+  of 600 USDT read with no `Amount` line, and the 600 USDT gets lines of its
-  `UNWRAP_WETH` and `BALANCE_CHECK_ERC20` (`PERMIT2_TRANSFER_FROM_BATCH`,
+  own. A step goes unread when its recipient does not decode as an address, when
-  `EXECUTE_SUB_PLAN` and the NFT commands among them), or a type its release
+  it is a V3 swap step whose path is shorter than one token address or has bytes
-  names no command for.
+  after its last hop, or when it is a command the decoder does not read: every
+  command other than `PERMIT2_PERMIT`, `PERMIT2_PERMIT_BATCH`,
+  `PERMIT2_TRANSFER_FROM`, `V2_SWAP_EXACT_IN`, `V2_SWAP_EXACT_OUT`,
+  `V3_SWAP_EXACT_IN`, `V3_SWAP_EXACT_OUT`, `V4_SWAP`, `SWEEP`, `TRANSFER`,
+  `PAY_PORTION`, `PAY_PORTION_FULL_PRECISION`, `ACROSS_V4_DEPOSIT_V3`,
+  `WRAP_ETH`, `UNWRAP_WETH` and `BALANCE_CHECK_ERC20`
+  (`PERMIT2_TRANSFER_FROM_BATCH`, `EXECUTE_SUB_PLAN` and the NFT commands among
+  them), or a type its release names no command for.
 
 ### Non-Goals Forever
 

src/shared/balances.js

@@ -1,4 +1,5 @@
-// Balance fetching: ETH balances via RPC, ERC-20 token balances via
+// Balance fetching: ETH balances and the balances of the tokens the user
+// tracks via RPC, the other ERC-20 token balances and the holder counts via
 // Blockscout, ENS reverse lookup via RPC.
 
 const {
@@ -81,7 +82,9 @@ 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.
+// explicitly tracked by the user, or have >= 1000 holders. A tracked token's
+// 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
@@ -205,8 +208,96 @@ async function fetchTokenBalances(
     }
 }
 
-// Fetch ETH balances, ENS names, and ERC-20 token balances for all addresses.
+// 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
+// for fetchTokenBalances().
 async function refreshBalances(
     wallets,
     rpcUrl,
@@ -217,6 +308,8 @@ 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) {
@@ -266,23 +359,42 @@ async function refreshBalances(
                     }),
             );
 
-            // ERC-20 token balances via Blockscout
+            // ERC-20 token balances: the tracked tokens' through the RPC
-            updates.push(
+            // endpoint, and from Blockscout the tokens the user has not
-                fetchTokenBalances(
+            // 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,
-                    trackedTokens,
+                tracked,
                 signal,
-                ).then((balances) => {
+            );
-                    if (balances !== null) {
+            updates.push(
-                        addr.tokenBalances = balances;
+                Promise.all([
+                    fetchTrackedTokenBalances(
+                        provider,
+                        addr.address,
+                        tracked,
+                        previous,
+                        explorerRequest,
+                        signal,
+                    ),
+                    explorerRequest,
+                ]).then(([trackedRows, explorerRows]) => {
+                    const untrackedRows = (explorerRows ?? previous).filter(
+                        (row) =>
+                            !trackedSet.has(String(row.address).toLowerCase()),
+                    );
+                    addr.tokenBalances = trackedRows.concat(untrackedRows);
                     log.debugf(
                         "Token balances",
                         addr.address,
-                            balances.length,
+                        addr.tokenBalances.length,
                         "tokens",
                     );
-                    }
                 }),
             );
         }

src/shared/uniswap.js

@@ -953,7 +953,9 @@ 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.
+//    for amountOutMin and the actions that buy Token Out, except that there
+//    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.
@@ -1187,12 +1189,14 @@ 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(
                     swaps
                         .filter((s) => s.tokenOut === tokenOut)
                         .map((s) => s.amountOutMin),
                 );
             }
+        }
 
         return {
             tokenIn,
@@ -1234,9 +1238,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         let inputToken = null;
         let inputAmount = null;
         let inputEstablished = false;
-        // Whether the user pays the V4 step that set the input side any of
+        // Whether the user pays the step that set the input side: a V2 or V3
-        // its input currency (see decodeV4Swap()). Only a V4 step can set the
+        // swap step with `payerIsUser` true, a V4 step the user pays some of
-        // input side with no amount, the one case in which this is read.
+        // its input currency (see decodeV4Swap()), or a WRAP_ETH, whose ETH
+        // 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).
@@ -1353,8 +1359,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         };
         // A PERMIT2_PERMIT or PERMIT2_PERMIT_BATCH at `step` whose input this
         // decoder cannot read may let any spender take any amount of any
-        // token: one line says so, and there is no Amount line, whose figure
+        // token: one line says so, there is no Amount line, whose figure may
-        // may then be too low.
+        // 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);
@@ -1622,6 +1629,7 @@ 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);
                         }
@@ -1645,6 +1653,7 @@ 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);
                         }
@@ -1676,6 +1685,7 @@ 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);
                         }
@@ -1771,10 +1781,13 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 } else if (command === "WRAP_ETH") {
                     const w = decodeWrapEth(inputs[i]);
                     if (w) {
+                        if (!inputEstablished) {
                             setInputOnce(
                                 "0x0000000000000000000000000000000000000000",
                                 w.amount,
                             );
+                            inputPaidByUser = true;
+                        }
                         addPayee(w.recipient);
                         // CONTRACT_BALANCE wraps all the router's ETH.
                         if (w.amount === CONTRACT_BALANCE) {
@@ -2021,8 +2034,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // Every other PERMIT2_PERMIT leaves Token In and the Amount line as
         // they read with no permit, and gets lines of its own below. A step
         // that may take from the sender what this decoder did not read leaves
-        // no figure, permit or not (see spentUnread()), and so does a permit
+        // no figure, permit or not (see spentUnread()), and so do a permit
-        // or batch whose input it cannot read (see permitUnread()). An
+        // 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,
@@ -2041,6 +2055,11 @@ 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
@@ -2053,6 +2072,9 @@ 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 };
             }
@@ -2071,6 +2093,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 typeof t.amount === "bigint"
             ) {
                 total += t.amount;
+                inTotal.push(t);
                 continue;
             }
             spentFromSender.push(t);
@@ -2199,14 +2222,30 @@ 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 one in `permits`, a permit or
+        // or a token it does not know, and an allowance to another spender
-        // batch it could not read, leave no Amount figure, which may then be
+        // that may be of Token In, leave no Amount figure, which may 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)) &&
-            permits.every((p) => present(p.token))
+            toAnotherSpender.every(
+                (p) =>
+                    present(p.token) &&
+                    present(inputToken) &&
+                    !sameAddress(p.token, inputToken),
+            )
         ) {
             const amount = spentText(inputAmount, inInfo);
             details.push({
@@ -2214,6 +2253,8 @@ 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
@@ -2325,9 +2366,10 @@ 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 and there is no such line. When no step names
+        // step pays the sender, there is no such line, and no allowance goes
-        // anyone paid, one line says so. `paidTo` holds these lines and the
+        // to another spender (see toAnotherSpender). When no step names anyone
-        // token line after each line about a token in the router.
+        // paid, one line says so. `paidTo` holds these lines and the token
+        // line after each line about a token in the router.
         const outputHeld =
             present(outputToken) && heldByRouter.has(outputToken.toLowerCase());
         const paidTo = paidElsewhere.map((address) => ({
@@ -2374,7 +2416,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         if (payeeUnread) {
             paidTo.push({ label: "Paid to", value: UNDECODED_CURRENCY });
         }
-        const received = paidToSender && paidTo.length === 0;
+        const received =
+            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,6 +18,11 @@ 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;
@@ -30,9 +35,9 @@ beforeEach(() => {
     const failedToFetch = async () => {
         throw new TypeError("Failed to fetch");
     };
-    // The RPC calls (ETH balance, ENS name, and the scan's balance and
+    // The RPC calls (ETH balance, ENS name, the tracked token's balance, and
-    // transaction count) and the explorer request (token balances) all fail
+    // the scan's balance and transaction count) and the explorer request (the
-    // the same way.
+    // other token balances) all fail the same way.
     FetchRequest.registerGetUrl(failedToFetch);
     globalThis.fetch = jest.fn(failedToFetch);
 });
@@ -49,7 +54,7 @@ function refresh(signal) {
         wallets,
         RPC_URL,
         EXPLORER_URL,
-        [],
+        [TRACKED],
         "mainnet",
         signal,
     );
@@ -60,6 +65,7 @@ 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,6 +3480,24 @@ 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/trackedTokenBalances.test.js

@@ -0,0 +1,303 @@
+// 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

@@ -1447,6 +1447,20 @@ 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) =>
@@ -1673,6 +1687,7 @@ 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"],
@@ -1693,6 +1708,7 @@ 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"],
@@ -1824,6 +1840,8 @@ 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([
             {
@@ -1871,6 +1889,7 @@ describe("uniswap decoder", () => {
                 [V3_600, encodeV4Swap(new Uint8Array(actions), params)],
             );
             expect(linesBetweenTokens(result)).toEqual([
+                ...USDT_600_GROUP,
                 ["Moved from the sender", UNDECODED],
             ]);
         });
@@ -1893,6 +1912,9 @@ 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",
@@ -1963,9 +1985,27 @@ describe("uniswap decoder", () => {
                     ),
                 ],
             },
-        ])("$kind", ({ commands, inputs }) => {
+            // Each take the total would add up gets lines of its own.
+            {
+                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],
             ]);
         });
@@ -1984,6 +2024,7 @@ 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"],
@@ -1995,6 +2036,7 @@ 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 + ")"],
@@ -2013,6 +2055,7 @@ 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 + ")"],
@@ -2065,12 +2108,6 @@ 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],
@@ -2290,6 +2327,103 @@ describe("uniswap decoder", () => {
             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) =>
@@ -2410,20 +2544,6 @@ 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],
@@ -2537,13 +2657,10 @@ describe("uniswap decoder", () => {
             const DAI_5000 = 5000000000000000000000n;
             const MAX_UINT160 = 2n ** 160n - 1n;
 
-            // A batch names one spender for all its allowances.
+            // A batch names one spender for all its allowances. One to
-            test.each([
+            // another spender is under "an allowance to a spender other than
-                { kind: "the router", spender: ROUTER_ADDR },
+            // the router" below.
-                { kind: "another spender", spender: OTHER_ADDR },
+            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", () => {
-            ])(
-                "a PERMIT2_PERMIT_BATCH of 5,000 USDT and unlimited DAI to $kind, then a V3 exact-in of 600 USDT, shows each allowance",
-                ({ spender }) => {
                 const result = decodeSteps(
                     [0x03, 0x00],
                     [
@@ -2552,7 +2669,7 @@ describe("uniswap decoder", () => {
                                 [USDT_ADDR, USDT_5000],
                                 [DAI_ADDR, MAX_UINT160],
                             ],
-                                spender,
+                            ROUTER_ADDR,
                         ),
                         V3_600,
                     ],
@@ -2564,9 +2681,9 @@ describe("uniswap decoder", () => {
                         "5000.0000 USDT",
                         USDT_ADDR,
                         "USDT",
-                            spender,
+                        ROUTER_ADDR,
                     ),
-                        ...permitLines("Unlimited", DAI_ADDR, "DAI", spender),
+                    ...permitLines("Unlimited", DAI_ADDR, "DAI", ROUTER_ADDR),
                 ]);
                 // A batch pays nobody, so the swap's minimum is what the
                 // sender receives.
@@ -2574,8 +2691,7 @@ describe("uniswap decoder", () => {
                 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.
@@ -2628,17 +2744,169 @@ describe("uniswap decoder", () => {
                     ),
                 },
             ])(
-                "$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",
+                "$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
@@ -2650,7 +2918,12 @@ 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);
@@ -2701,6 +2974,9 @@ 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),
             ]);
@@ -2856,14 +3132,15 @@ describe("uniswap decoder", () => {
         );
 
         // The V4 exact-out route above the other way round, where the later
-        // take's unknown amount leaves no figure at all, and other ways the
+        // take's unknown amount leaves no Amount figure and the 400 USDT gets
-        // step that sets the input side states no amount.
+        // lines of its own, and other ways the step that sets the input side
+        // 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: UNKNOWN_USDT,
+                lines: [...UP_TO_400_USDT, ...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",
@@ -3453,6 +3730,88 @@ 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,6 +1332,10 @@ 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",
@@ -1432,15 +1436,24 @@ describe("any token left in the router is not received", () => {
             ),
             left: { label: "Token moved into the router", value: "ETH" },
         },
-    ])("$kind", ({ data, left, spent, unread }) => {
+    ])("$kind", ({ data, left, spent, unread, noMin }) => {
         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),
-            unread ? "Moved from the sender" : "Amount",
+            // after the lines the WRAP_ETH's 1 ETH then gets
+            // (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
@@ -1449,7 +1462,7 @@ describe("any token left in the router is not received", () => {
             "Token Out",
             "Paid to",
             "Token moved into the router",
-            "Min. paid out",
+            ...(noMin ? [] : ["Min. paid out"]),
             "Steps",
             "Deadline",
         ]);
@@ -1457,13 +1470,17 @@ describe("any token left in the router is not received", () => {
             expect(detail(result, "Moved from the sender").value).toBe(spent);
         }
         if (unread) {
-            expect(detail(result, "Moved from the sender").value).toBe(
+            expect(
-                UNDECODED,
+                result.details
-            );
+                    .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("1990.0000 USDC");
+        expect(detail(result, "Min. paid out")?.value).toBe(
+            noMin ? undefined : "1990.0000 USDC",
+        );
     });
 
     // Uniswap's own routes: a swap paid in ETH wraps into the router what its
@@ -2791,26 +2808,37 @@ 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 }) => {
+        ({ address, mark, minimum }) => {
             const steps = [
                 permit2Permit(USDT, USDT_2000),
                 swapToWeth(MSG_SENDER),
@@ -2842,7 +2870,7 @@ describe("the allow-revert flag", () => {
             expect(
                 labels(withFlag).filter((l) => permitLines.includes(l)),
             ).toEqual(permitLines);
-            expect(detail(withFlag, "Min. received").value).toBe("1.0000 WETH");
+            expect(detail(withFlag, minimum).value).toBe("1.0000 WETH");
         },
     );