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

@@ -17,11 +17,11 @@ and don't implement any crypto. By default the wallet sends user-specific data
 only to the Ethereum RPC endpoint. The user can change that endpoint in
 Settings. The endpoint defaults to a public node.
 
-Out of the box the extension contacts two services:
+Out of the box the extension contacts one service, the configured RPC node. The
+wallet uses the node for:
 
-- the configured RPC node, for blockchain interactions
+- blockchain interactions
-- a public CoinDesk API (no API key), for realtime prices. The API receives
+- USD prices on mainnet, read from Chainlink price feed contracts
-  token symbols and nothing else.
 
 Two more services are sent none of the user's data until the user ticks a
 checkbox for each. Welcome and Settings both offer the two checkboxes:
@@ -902,13 +902,14 @@ src/
     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
-    prices.js         — ETH/USD and token/USD via CoinDesk API
+    prices.js         — ETH/USD and token/USD from Chainlink price feeds
     scamlist.js       — known fraud contract addresses
     state.js          — persisted state (extension storage)
     storedSettings.js — "Use Blockscout" and "Check recipients on Etherscan",
                         read from storage for the requests those settings gate
     symbolSpoof.js    — the known-symbol spoof rule, shared by all surfaces
-    tokenList.js      — top ERC-20 tokens by market cap (hardcoded)
+    tokenList.js      — top ERC-20 tokens by market cap, and their Chainlink
+                        price feeds (hardcoded)
     transactions.js   — tx history fetching + anti-poisoning filters
     uniswap.js        — Uniswap Universal Router calldata decoder
     vault.js          — password-based encryption via libsodium
@@ -1265,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
@@ -1276,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
+- `None (no minimum guaranteed)`: the swap's `Min. received` line, when it shows
-  minimum it shows is zero, whether a V2, V3 or V4 swap's minimum or a
+  a V2, V3 or V4 swap's minimum of zero. The router passes a
-  `BALANCE_CHECK_ERC20` step's `minBalance`. Before
+  `BALANCE_CHECK_ERC20` step whenever the balance is at least `minBalance`, so a
-  [#359](https://git.eeqj.de/sneak/AutistMask/issues/359), a zero `minBalance`
+  zero `minBalance` guarantees nothing. A check with a zero `minBalance` sets
-  read `0.0000` when the token's scale was known. The router passes a balance
+  neither `Token Out` nor `Min. received`. A nonzero `minBalance` sets both
-  check whenever the balance is at least `minBalance`, so a zero `minBalance`
+  lines, as a swap step does. Only a check of the transaction's sender's own
-  guarantees nothing: it sets `Token Out` and `Min. received` only when the
+  balance sets either line; a check of any other address sets neither (see
-  output side holds no minimum, not even a zero one, at the point the check is
+  Transaction Decoding). A `BALANCE_CHECK_ERC20` step that the router lets fail
-  reached, and otherwise leaves the current token and figure in place. A nonzero
+  without reverting the transaction (see Transaction Decoding) guarantees
-  `minBalance` sets both lines, as a swap step does. Only a check of the
+  nothing either, whatever its `minBalance`, and is read as one whose
-  transaction's sender's own balance sets either line; a check of any other
+  `minBalance` is zero. A minimum stated by a V4 swap step the router lets fail
-  address sets neither (see Transaction Decoding). A `BALANCE_CHECK_ERC20` step
+  is likewise read as zero.
-  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
@@ -1371,10 +1369,10 @@ whole swap undecoded.
 
 #### Partial USD totals
 
-Prices are fetched for the top 25 tokens only, so an address can hold assets the
+Only a token with a Chainlink price feed has a price, so an address can hold
-extension has no price for. Worth zero and worth an unknown amount are different
+assets the extension has no price for. Worth zero and worth an unknown amount
-facts and are never collapsed into one number. `getAddressValue()` in
+are different facts and are never collapsed into one number. `getAddressValue()`
-`src/shared/prices.js` returns `{ usd, partial }` — the value of the priced
+in `src/shared/prices.js` returns `{ usd, partial }` — the value of the priced
 holdings, and whether an unpriced holding was left out of it — and every screen
 renders it through `formatAddressTotal()`, so the wording cannot drift:
 
@@ -2280,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
@@ -2820,6 +2820,9 @@ view would leave a wallet one click from deletion.
     - "Export Saved Data" button, and the read-only text box it fills
     - What erasing does and does not do, in bold: every wallet stored in this
       browser is deleted; nothing on chain changes and no money is moved
+    - What a wallet can be added again from: a kept copy of its recovery phrase,
+      private key or extended private key. Without that copy or the exported
+      copy, everything the wallet holds is gone forever.
     - A text input asking for `ERASE MY WALLET` to be typed back
     - Error line
     - "Erase Saved Data" button
@@ -2851,9 +2854,9 @@ view would leave a wallet one click from deletion.
 
 ### External Services
 
-AutistMask is not a fully self-contained offline tool. By default it sends the
+AutistMask is not a fully self-contained offline tool. By default it contacts
-user's data only to the Ethereum RPC endpoint. It also asks the CoinDesk price
+only the Ethereum RPC endpoint. USD prices are read from Chainlink price feed
-API for prices, sending token symbols and nothing else.
+contracts through that endpoint.
 
 Two more services are sent none of the user's data until the user turns on a
 setting for each:
@@ -2877,21 +2880,18 @@ Contacted by default:
   estimate gas (`eth_estimateGas`), fetch nonces (`eth_getTransactionCount`),
   broadcast transactions (`eth_sendRawTransaction`), and check transaction
   receipts. Every ENS lookup is made through the RPC endpoint alone. So a name
-  does not resolve when its resolver says the name is resolved off-chain. The
+  does not resolve when its resolver says the name is resolved off-chain. On
-  default endpoint is a public RPC (configurable by the user to any endpoint
+  mainnet the extension also reads USD prices from Chainlink price feed
-  they prefer, including a local node). By default the extension talks to
+  contracts (`latestRoundData`). The prices of ETH and of each held or tracked
+  token with a feed are read as one batched request. That request is sent at
+  most every 5 minutes while the popup is open. The default endpoint is a public
+  RPC (configurable by the user to any endpoint they prefer, including a local
+  node). By default the extension talks to
   `https://ethereum-rpc.publicnode.com`.
     - **Data sent**: Ethereum addresses, transaction data, contract call
       parameters. The RPC endpoint can see all on-chain queries and submitted
       transactions.
 
-- **CoinDesk CADLI price API**: Used to fetch ETH/USD and token/USD prices for
-  displaying fiat values. The price is cached for 5 minutes to avoid excessive
-  requests. No API key required. No user data is sent — only a list of token
-  symbols. Note that CoinDesk will receive your client IP.
-    - **Data sent**: Token symbol strings only (e.g. "ETH", "USDC"). No
-      addresses or user-specific data.
-
 Sent the user's data only while its setting is on:
 
 - **Blockscout block-explorer API** ("Use Blockscout"): The default endpoint is
@@ -3067,14 +3067,13 @@ hardcoded test phrase.
 
 At the raised log level the console also shows the wallet's addresses with their
 balances and ENS names, the token contracts looked up, and a line for each
-request made through `debugFetch` in `src/shared/log.js` (the explorer, the
+request made through `debugFetch` in `src/shared/log.js` (the explorer, the RPC
-price feed, the RPC calls a site makes, and the endpoint checks in settings) and
+calls a site makes, and the endpoint checks in settings) and for its response. A
-for its response. A request is logged by its HTTP method, the origin of its URL
+request is logged by its HTTP method, the origin of its URL (scheme, host and
-(scheme, host and port) and, for a JSON-RPC call, the method name; the balance
+port) and, for a JSON-RPC call, the method name; the balance refresh, the token
-refresh, the token lookup and a failed endpoint check in settings name the
+lookup and a failed endpoint check in settings name the endpoint by its origin
-endpoint by its origin too. The URL's path and query string, where RPC providers
+too. The URL's path and query string, where RPC providers put API keys, any user
-put API keys, any user name and password in it, and the request body are never
+name and password in it, and the request body are never logged.
-logged.
 
 ### Key Decisions
 
@@ -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
@@ -3412,47 +3412,43 @@ Currently supported:
   as a swap paid in ETH does, but only when that amount is not
   `CONTRACT_BALANCE` and the router held no WETH from an earlier step when the
   `WRAP_ETH` ran: after two `WRAP_ETH`s of 0.5 ETH into the router, a swap of 1
-  WETH from it reads as leaving the WETH there. An `UNWRAP_WETH` into the router
+  WETH from it reads as leaving the WETH there. A V2 or V3 exact-out step paid
-  turns all the router's WETH into as much ETH. The decoder then knows how much
+  from the router spends an amount the calldata does not state, at most its
-  ETH the router holds only when it knew the WETH's amount and the router held
+  `amountInMax`, so the decoder counts it as spending nothing the router holds.
-  no ETH before. A V4 `SETTLE` of ETH spends the ETH the router holds, whoever
+  A `SETTLE` of `OPEN_DELTA` (zero), and a `SETTLE_ALL`, pay only what the step
-  pays it (see below). A V2 or V3 exact-out step paid from the router spends an
+  still owes of their token when they run. The decoder takes that to be the
-  amount the calldata does not state, at most its `amountInMax`, so the decoder
+  amounts the step's swap actions state they spend of that token only when every
-  counts it as spending nothing the router holds. A `SETTLE` of `OPEN_DELTA`
+  action in the step could be read, every swap action names the token it spends
-  (zero), and a `SETTLE_ALL`, pay only what the step still owes of their token
+  and the token it buys (a swap action with an empty path swaps nothing), the
-  when they run. The decoder takes that to be the amounts the step's swap
+  `SETTLE` or `SETTLE_ALL` is the step's only `SETTLE` or `SETTLE_ALL` of that
-  actions state they spend of that token only when every action in the step
+  token and comes after every swap action, no swap action buys that token, no
-  could be read, every swap action names the token it spends and the token it
+  `TAKE`, `TAKE_ALL` or `TAKE_PORTION` in the step takes it (a `TAKE` of a
-  buys (a swap action with an empty path swaps nothing), the `SETTLE` or
+  stated amount adds to what the step owes), and the swap actions that spend it
-  `SETTLE_ALL` is the step's only `SETTLE` or `SETTLE_ALL` of that token and
+  state a quantity together; otherwise it does not know the amount, and such a
-  comes after every swap action, no swap action buys that token, no `TAKE`,
+  `SETTLE` from the router counts as spending nothing. So the rest of a V4
-  `TAKE_ALL` or `TAKE_PORTION` in the step takes it (a `TAKE` of a stated amount
+  `SETTLE` of more than its swap spends, taken to the router, the WETH of a
-  adds to what the step owes), and the swap actions that spend it state a
+  `WRAP_ETH`, and a token a swap pays the router on the way to the output, each
-  quantity together; otherwise it does not know the amount, and such a `SETTLE`
+  stays in the router when later steps do not spend all of it, where anyone can
-  from the router counts as spending nothing. So the rest of a V4 `SETTLE` of
+  take it in a later transaction. The router sends ETH as written, so a
-  more than its swap spends, taken to the router, the WETH of a `WRAP_ETH`, and
+  `TRANSFER` of `CONTRACT_BALANCE` of ETH always reverts and pays out nothing. A
-  a token a swap pays the router on the way to the output, each stays in the
+  step paying a token to the V2 pair that the very next step spends, as a V2
-  router when later steps do not spend all of it, where anyone can take it in a
+  exact-in of that token whose `amountIn` is `ALREADY_PAID` (zero) or
-  later transaction. The router sends ETH as written, so a `TRANSFER` of
+  `CONTRACT_BALANCE`, is a hop, not a payout: Uniswap's mixed routes pay the
-  `CONTRACT_BALANCE` of ETH always reverts and pays out nothing. A step paying a
+  next V2 pair directly, and the router enforces that swap's own minimum. The
-  token to the V2 pair that the very next step spends, as a V2 exact-in of that
+  decoder checks that the address paid is that pair, deriving it from the V2
-  token whose `amountIn` is `ALREADY_PAID` (zero) or `CONTRACT_BALANCE`, is a
+  factory and pair init code hash the network's routers were deployed with and
-  hop, not a payout: Uniswap's mixed routes pay the next V2 pair directly, and
+  the first two tokens of that step's path; a payment to any other address is
-  the router enforces that swap's own minimum. The decoder checks that the
+  named. (Sepolia's `UniversalRouterV1_2_V2Support` was deployed with
-  address paid is that pair, deriving it from the V2 factory and pair init code
+  placeholders for both values, so no V2 swap step can succeed on that router.)
-  hash the network's routers were deployed with and the first two tokens of that
+  Every other payment counts, in whichever step and of whatever token, a share
-  step's path; a payment to any other address is named. (Sepolia's
+  of the output included: an interface fee paid to another address by
-  `UniversalRouterV1_2_V2Support` was deployed with placeholders for both
+  `PAY_PORTION`, `TRANSFER` or `TAKE_PORTION` is named, and the minimum reads
-  values, so no V2 swap step can succeed on that router.) Every other payment
+  `Min. paid out`, because the swap's minimum includes the fee. The minimum
-  counts, in whichever step and of whatever token, a share of the output
+  reads `Min. received` only when some step pays the transaction's sender (the
-  included: an interface fee paid to another address by `PAY_PORTION`,
+  From address on TxApproval, the sender the explorer reports on
-  `TRANSFER` or `TAKE_PORTION` is named, and the minimum reads `Min. paid out`,
+  TransactionDetail), no `Paid to` line is shown, and no permit or batch grants
-  because the swap's minimum includes the fee. The minimum reads `Min. received`
+  an allowance to a spender other than the router (see below). `Paid to` lines
-  only when some step pays the transaction's sender (the From address on
+  after `Token Out` name each other address paid; one reads
-  TxApproval, the sender the explorer reports on TransactionDetail), no
-  `Paid to` line is shown, and no permit or batch grants 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)`
@@ -3464,39 +3460,50 @@ 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
+  minimum reads `Min. paid out`. The step that sets the output side gives the
-  take of `Token In`, from the step that sets the input side on: the first V2 or
+  minimum. When that step and earlier swap steps each pay the output token to
-  V3 exact-in or exact-out, `WRAP_ETH` or V4 swap step that names an input token
+  the transaction's sender, the minimum is the sum of their minimums. There is
-  or amount. A V4 step with a swap action sets the input side when no earlier
+  no minimum when the decoder reads none from one of them, or when one of them
-  step set it, even when it names neither (see Display Consistency). That step
+  pays part of that token elsewhere. There is also no minimum when the decoder
-  counts its own amount, whoever pays it: a V2 or V3 exact-out step its
+  did not read one of them, or a step between them, in full. A swap step that
-  `amountInMax`, and a V4 step what it takes of its input token from the user's
+  spends the output token drops earlier steps from the sum. A V4 step spends
-  wallet, as below, or, when the user pays it none of that token, the `amountIn`
+  each token that its swap actions spend. A V4 `SETTLE` or `SETTLE_ALL` of the
-  of the swap action that spends it. Each later V2 or V3 exact-in or exact-out
+  output token also drops earlier steps. A `PERMIT2_TRANSFER_FROM` of the output
-  step whose `payerIsUser` is true takes its amount, found in the same way, from
+  token drops earlier steps too. A step after the step that sets the output side
-  the user's wallet. Every V4 step, with a swap action or without, takes from
+  drops nothing from the sum. The `Amount` line gives the total the steps take
-  the user's wallet what its `SETTLE`s paid by the user (`payerIsUser` true) and
+  of `Token In`, from the step that sets the input side on: the first V2 or V3
-  its `SETTLE_ALL`s pay, for each token on its own; what the step that sets the
+  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
   that swaps 400 USDT, with a `SETTLE` of 5,000 USDT paid by the user and the
-  rest taken to another address, reads `5000.0000 USDT`. V4 pays ETH from the
+  rest taken to another address, reads `5000.0000 USDT`. A later step that pays
-  router's own ETH, whoever a `SETTLE` names as payer. So when a V4 step would
+  an ERC-20 token from the router takes none of that token from the user's
-  take ETH from the user's wallet, ETH the router already holds pays first. The
+  wallet. A V2 exact-in whose `amountIn` is `ALREADY_PAID` takes nothing either.
-  wallet pays only the rest. For example, an `UNWRAP_WETH` into the router
+  A V4 `SETTLE` of ETH paid from the router still takes from the user's wallet,
-  leaves ETH there. When the decoder does not know how much ETH the router
+  since the router holds the transaction's value. When the decoder does not know
-  holds, or how much the step would take, it counts the router as paying all of
+  the amount of such a `SETTLE`, as for `CONTRACT_BALANCE`, that `SETTLE` counts
-  that ETH. A later step paid from the router spends what the router holds and
+  as a later step's take. When an earlier step left ETH in the router, that ETH
-  takes nothing, and so does a V2 exact-in whose `amountIn` is `ALREADY_PAID`. A
+  may pay part of a `SETTLE` of ETH paid from the router. That `SETTLE` then
-  later take of `Token In` is added to the total while both are quantities: a V3
+  gets lines of its own, with `Up to` before its amount. A later take of
-  exact-in of 600 USDT and a V2 exact-in of 400 USDT, both paid by the user,
+  `Token In` that only the user's wallet pays is added to the total while both
-  read `1000.0000 USDT`. When the decoder does not know a take's amount, the
+  are quantities: a V3 exact-in of 600 USDT and a V2 exact-in of 400 USDT, both
-  total is not known and there is no `Amount` line. A `PERMIT2_PERMIT` names
+  paid by the user, read `1000.0000 USDT`. When the decoder does not know a
-  `Token In` only when its amount, `Unlimited` included, stands as the `Amount`
+  take's amount, the total is not known and there is no `Amount` line. A
-  figure in place of the total, which it does only in the plain shape of
+  `PERMIT2_PERMIT` names `Token In` only when its amount, `Unlimited` included,
-  Uniswap's own routes: it comes before the step that sets the input side, it is
+  stands as the `Amount` figure in place of the total, which it does only in the
-  the only `PERMIT2_PERMIT` in the transaction and there is no
+  plain shape of Uniswap's own routes: it comes before the step that sets the
+  input side, it is the only `PERMIT2_PERMIT` in the transaction and there is no
   `PERMIT2_PERMIT_BATCH`, its spender is the router, the router may not let it
   fail, no step before it takes its token, a `PERMIT2_TRANSFER_FROM` of it
   included, or a token the decoder does not know, and the decoder reads every
@@ -3515,93 +3522,98 @@ Currently supported:
   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
+  that exact-in and then a permit of 5,000 DAI to the router. A permit on the
-  amount stands and the step that sets the input side spends a token other than
+  zero address never stands as the `Amount` figure, because Permit2 has no
-  the permit's, or one the decoder does not know, that step's amount gets lines
+  allowance of ETH. When a permit's amount stands and the step that sets the
-  of its own, unless it states no amount and the user pays it none of its input
+  input side spends a token other than the permit's, or one the decoder does not
-  token. Each take the total does not count gives three lines after the `Amount`
+  know, that step's amount gets lines of its own, unless it states no amount and
-  line (after `Token In` when there is none): one of a token other than
+  the user pays it none of its input token. Each take the total does not count
-  `Token In`; one of `Token In` after an amount that is not a quantity (a V4
+  gives three lines after the `Amount` line (after `Token In` when there is
-  open delta, `ALREADY_PAID`, which keep their wording on the `Amount` line, or
+  none): one of a token other than `Token In`; one of `Token In` after an amount
-  no stated amount, as of a V4 exact-out step); and one whose amount the decoder
+  that is not a quantity (a V4 open delta, `ALREADY_PAID`, which keep their
-  does not know. When there is no `Amount` line, each take the total counts gets
+  wording on the `Amount` line, or no stated amount, as of a V4 exact-out step);
-  them too, so that every amount the decoder reads is shown: the amount the step
+  an ETH take whose line reads `Up to` (see above); and one whose amount the
-  that sets the input side states, when it is a quantity and the user pays that
+  decoder does not know. When there is no `Amount` line, each take the total
-  step (a V2 or V3 step whose `payerIsUser` is true, a V4 step the user pays
+  counts gets them too, so that every amount the decoder reads is shown: the
-  some of its input token, or a `WRAP_ETH`, whose ETH comes from the
+  amount the step that sets the input side states, when it is a quantity and the
-  transaction's value), and each later take of `Token In` added to it. A step
+  user pays that step (a V2 or V3 step whose `payerIsUser` is true, a V4 step
-  that sets the input side and is paid from the router takes nothing from the
+  the user pays some of its input token, or a `WRAP_ETH`, whose ETH comes from
-  user's wallet and gets none. A `PERMIT2_PERMIT` the decoder cannot read, then
+  the transaction's value), and each later take of `Token In` added to it. A
-  V3 exact-ins of 600 USDT and 400 DAI paid by the user, give lines for both
+  step that sets the input side gets none when the user pays it none of its
-  amounts. When the step that sets the input side states no amount, the user
+  input token. A `PERMIT2_PERMIT` the decoder cannot read, then V3 exact-ins of
-  pays it some of its input token, and there is no `Amount` line, that step gets
+  600 USDT and 400 DAI paid by the user, give lines for both amounts. When the
-  them too whenever another take's lines give a figure, or a
+  step that sets the input side states no amount, the user pays it some of its
-  `PERMIT2_TRANSFER_FROM` of its token gives one, on the lines below or, into
+  input token, and there is no `Amount` line, that step gets them too whenever
-  the router, on its `Paid to` line, so that figure cannot read as all that
+  another take's lines give a figure, or a `PERMIT2_TRANSFER_FROM` of its token
-  leaves. When it states no amount and the user pays it none of its input token,
+  gives one, on the lines below or, into the router, on its `Paid to` line, so
-  as when the router pays it, that step takes none of that token from the user's
+  that figure cannot read as all that leaves. When it states no amount and the
-  wallet and never gets them, with a permit or without. They come in step order,
+  user pays it none of its input token, that step never gets them, with a permit
-  except that the step that sets the input side comes first when it has them,
+  or without. They come in step order, except that the step that sets the input
-  followed, when there is no `Amount` line, by the other takes the total counts:
+  side comes first when it has them, followed, when there is no `Amount` line,
-  `Moved from the sender`, its amount, worded as the `Amount` line words one, or
+  by the other takes the total counts: `Moved from the sender`, its amount,
-  `Unknown (could not be decoded)` when the decoder does not know it;
+  worded as the `Amount` line words one, or `Unknown (could not be decoded)`
-  `Token moved`, giving the token's address as the `Token In` line does; and
+  when the decoder does not know it; `Token moved`, giving the token's address
-  `Moved to`, which reads `The swap step that spends it`. For a `WRAP_ETH` that
+  as the `Token In` line does; and `Moved to`, which reads
-  pays its WETH to anyone but the router, `Moved to` names that recipient
+  `The swap step that spends it`. A token the decoder does not know gives the
-  instead: `The sender` for `address(1)`, and otherwise the address. A token the
+  `Moved from the sender` line alone. A step may also take from the user's
-  decoder does not know gives the `Moved from the sender` line alone. A step may
+  wallet what the decoder did not read: a V4 step whose input or one of whose
-  also take from the user's wallet what the decoder did not read: a V4 step
+  `SETTLE`s or `SETTLE_ALL`s it cannot read, which the router still runs; a V2
-  whose input or one of whose `SETTLE`s or `SETTLE_ALL`s it cannot read, which
+  or V3 exact-in or exact-out step or a `PERMIT2_TRANSFER_FROM` whose input it
-  the router still runs; a V2 or V3 exact-in or exact-out step or a
+  cannot read, such as a V3 step whose path is shorter than one token address or
-  `PERMIT2_TRANSFER_FROM` whose input it cannot read, such as a V3 step whose
+  has bytes after its last hop; every `PERMIT2_TRANSFER_FROM_BATCH`; every
-  path is shorter than one token address or has bytes after its last hop; every
+  `EXECUTE_SUB_PLAN`, wherever it stands; and every step it fails on. Each such
-  `PERMIT2_TRANSFER_FROM_BATCH`; every `EXECUTE_SUB_PLAN`, wherever it stands;
+  step gives one `Moved from the sender` line among those, reading
-  and every step it fails on. Each such step gives one `Moved from the sender`
+  `Unknown (could not be decoded)`. That line, or any line for a token the
-  line among those, reading `Unknown (could not be decoded)`. That line, or any
+  decoder does not know, leaves no `Amount` line, whose figure might be too low,
-  line for a token the decoder does not know, leaves no `Amount` line, whose
+  and such a step before a `PERMIT2_PERMIT` keeps the permit's amount from
-  figure might be too low, and such a step before a `PERMIT2_PERMIT` keeps the
+  standing. Then each `PERMIT2_TRANSFER_FROM` but one into the router, in step
-  permit's amount from standing. Then each `PERMIT2_TRANSFER_FROM` but one into
+  order, gives three lines: `Moved from the sender`, the amount it moves, for
-  the router, in step order, gives three lines: `Moved from the sender`, the
+  example `1000000.0000 USDT`; `Token moved`, giving the token's address as the
-  amount it moves, for example `1000000.0000 USDT`; `Token moved`, giving the
+  `Token In` line does; and `Moved to`, which reads
-  token's address as the `Token In` line does; and `Moved to`, which reads
   `The V2 pair the next swap spends` for a hop and `The sender` for `address(1)`
   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
+  where it goes, and so its amount is shown once. For a move of the zero
-  amount does not stand as the `Amount` figure, before the step that sets the
+  address, `Moved from the sender` gives the amount in base units and
-  input side or after it, gives three lines, in step order, after those for each
+  `Token moved` gives the zero address. For such a move into the router, the
-  `PERMIT2_TRANSFER_FROM`: `Permit2 allowance`, its amount, for example
+  `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
   amount stands gives none: the `Amount` line gives its amount, `Token In` its
   token, and its spender is the router. Each allowance a `PERMIT2_PERMIT_BATCH`
   grants, one for each token it names, all for its one spender, gives the same
-  three lines, in step order with those of each `PERMIT2_PERMIT`. A
+  three lines, in step order with those of each `PERMIT2_PERMIT`. For an
-  `PERMIT2_PERMIT` or `PERMIT2_PERMIT_BATCH` whose input the decoder cannot
+  allowance of the zero address, `Permit2 allowance` gives the amount in base
-  read, such as one whose token or spender word has a nonzero top byte, may let
+  units and `Allowance token` gives the zero address. A `PERMIT2_PERMIT` or
-  any spender take any amount of any token: it gives one `Permit2 allowance`
+  `PERMIT2_PERMIT_BATCH` whose input the decoder cannot read, such as one whose
-  line alone, reading `Unknown (could not be decoded)`. These lines change no
+  token or spender word has a nonzero top byte, may let any spender take any
-  `Paid to` line: a permit or batch pays nobody. But code that a step runs, such
+  amount of any token: it gives one `Permit2 allowance` line alone, reading
-  as a V4 pool's hook or a token's own code, can call a spender other than the
+  `Unknown (could not be decoded)`. These lines change no `Paid to` line: a
-  router, which can then take up to its allowance from the user's wallet before
+  permit or batch pays nobody. But code that a step runs, such as a V4 pool's
-  the transaction ends. So an allowance to any spender but the router, or a
+  hook or a token's own code, can call a spender other than the router, which
-  permit or batch the decoder cannot read, makes the minimum read
+  can then take up to its allowance from the user's wallet before the
-  `Min. paid out`, and when its token is `Token In`, or the decoder does not
+  transaction ends. So an allowance to any spender but the router, or a permit
-  know its token or `Token In`, it leaves no `Amount` line, whose figure might
+  or batch the decoder cannot read, makes the minimum read `Min. paid out`, and
-  be too low: a permit of 5,000 USDT to another address and then a V3 exact-in
+  when its token is `Token In`, or the decoder does not know its token or
-  of 600 USDT read with no `Amount` line, and the 600 USDT gets lines of its
+  `Token In`, it leaves no `Amount` line, whose figure might be too low: a
-  own. A step goes unread when its recipient does not decode as an address, when
+  permit of 5,000 USDT to another address and then a V3 exact-in of 600 USDT
-  it is a V3 swap step whose path is shorter than one token address or has bytes
+  read with no `Amount` line, and the 600 USDT gets lines of its own. A step
-  after its last hop, or when it is a command the decoder does not read: every
+  goes unread when its recipient does not decode as an address, when it is a V3
-  command other than `PERMIT2_PERMIT`, `PERMIT2_PERMIT_BATCH`,
+  swap step whose path is shorter than one token address or has bytes after its
-  `PERMIT2_TRANSFER_FROM`, `V2_SWAP_EXACT_IN`, `V2_SWAP_EXACT_OUT`,
+  last hop, or when it is a command the decoder does not read: every command
-  `V3_SWAP_EXACT_IN`, `V3_SWAP_EXACT_OUT`, `V4_SWAP`, `SWEEP`, `TRANSFER`,
+  other than `PERMIT2_PERMIT`, `PERMIT2_PERMIT_BATCH`, `PERMIT2_TRANSFER_FROM`,
-  `PAY_PORTION`, `PAY_PORTION_FULL_PRECISION`, `ACROSS_V4_DEPOSIT_V3`,
+  `V2_SWAP_EXACT_IN`, `V2_SWAP_EXACT_OUT`, `V3_SWAP_EXACT_IN`,
-  `WRAP_ETH`, `UNWRAP_WETH` and `BALANCE_CHECK_ERC20`
+  `V3_SWAP_EXACT_OUT`, `V4_SWAP`, `SWEEP`, `TRANSFER`, `PAY_PORTION`,
-  (`PERMIT2_TRANSFER_FROM_BATCH`, `EXECUTE_SUB_PLAN` and the NFT commands among
+  `PAY_PORTION_FULL_PRECISION`, `ACROSS_V4_DEPOSIT_V3`, `WRAP_ETH`,
-  them), or a type its release names no command for.
+  `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
 

docs/README.md

@@ -70,9 +70,9 @@ analytics, use a portfolio tracker. The wallet is not the place for any of that.
 ## How It Works
 
 AutistMask is a browser extension that runs entirely in your browser. It does
-not have a backend server. Out of the box it sends your data only to the
+not have a backend server. Out of the box it contacts only the Ethereum RPC
-Ethereum RPC endpoint. It also asks the CoinDesk price API for prices, sending
+endpoint. USD prices are read from Chainlink price feed contracts through that
-token symbols and nothing else.
+endpoint.
 
 Blockscout and Etherscan are sent none of your data until you turn on a setting
 for each. The settings are "Use Blockscout" and "Check recipients on Etherscan".
@@ -89,10 +89,16 @@ verify confirmations. The default is a free public RPC endpoint. You can change
 this in Settings to any Ethereum JSON-RPC endpoint, including your own local
 node.
 
+On mainnet, AutistMask also reads USD prices through this endpoint. The prices
+come from Chainlink's price feed contracts. A token with no Chainlink feed shows
+no USD value.
+
 When it is contacted:
 
 - on every balance refresh (every 10 seconds while the popup is open, every 60
   seconds in the background)
+- on mainnet, to read USD prices, at most every 5 minutes while the popup is
+  open
 - when you review a send to an ENS name
 - when a send is prepared and broadcast
 - while a pending transaction is polled for its receipt
@@ -131,19 +137,6 @@ sends none of your data.
 What gets sent: your Ethereum addresses (to look up balances and transactions)
 and the hash of each transaction you open.
 
-**CoinDesk CADLI price API** (`data-api.coindesk.com`)
-
-Used to fetch current USD prices for ETH and the top 25 tokens. Prices are
-cached for 5 minutes. No API key is required. This endpoint is not
-user-configurable, and it is not contacted at all while you are on a testnet,
-where no USD values are shown.
-
-When it is contacted: while the popup is open, at most once every 5 minutes.
-
-What gets sent: token symbol names (e.g. "ETH", "USDC"). No addresses, no
-balances, no identifying information. As with any request, CoinDesk sees your IP
-address.
-
 **Etherscan address labels** (`etherscan.io`; `sepolia.etherscan.io` on Sepolia)
 
 While "Check recipients on Etherscan" is on, AutistMask fetches the recipient's

src/popup/index.html

@@ -1994,10 +1994,11 @@
                         >Erasing the saved data deletes every wallet stored in
                         this browser.</strong
                     >
-                    Nothing on the blockchain changes and no money is moved, but
+                    Nothing on the blockchain changes and no money is moved. If
-                    without the exported copy above, or the recovery phrase for
+                    you kept a copy of a wallet's recovery phrase, private key
-                    each wallet written down, everything they hold is gone
+                    or extended private key, you can add that wallet again.
-                    forever.
+                    Without that copy or the exported copy above, everything the
+                    wallet holds is gone forever.
                 </p>
                 <p class="text-xs mb-1">
                     To confirm, type

src/popup/index.js

@@ -96,7 +96,7 @@ async function doRefreshAndRender() {
         const networkId = state.networkId;
         const wallets = structuredClone(state.wallets);
         await Promise.all([
-            refreshPrices(),
+            refreshPrices(pageClosed.signal),
             refreshBalances(
                 wallets,
                 state.rpcUrl,

src/popup/views/addressToken.js

@@ -69,7 +69,7 @@ function show() {
         // null when the scale is unknown: no quantity to show, and none to
         // price. balanceLine() states that rather than printing 0.0000.
         amount = tb ? unknownableAmount(tb.balance) : 0;
-        price = getPrice(symbol);
+        price = getPrice(tokenId);
     }
 
     currentSymbol = symbol;

src/popup/views/confirmTx.js

@@ -129,7 +129,7 @@ function renderAmount(txInfo) {
     const rawSymbol = isErc20
         ? txInfo.tokenSymbol || "?"
         : nativeCurrencyByChainId(txInfo.chainId);
-    const price = getPrice(isErc20 ? rawSymbol : "ETH", txInfo.chainId);
+    const price = getPrice(txInfo.token, txInfo.chainId);
     const amountUsd = price ? parseFloat(txInfo.amount) * price : null;
     $("confirm-amount").textContent = valueWithUsd(
         shownAmount(txInfo) + " " + displaySymbol(rawSymbol),
@@ -157,7 +157,7 @@ function renderBalance(txInfo) {
         $("confirm-balance").textContent = "unknown (" + symbol + ")";
         return;
     }
-    const price = getPrice(isErc20 ? rawSymbol : "ETH", txInfo.chainId);
+    const price = getPrice(txInfo.token, txInfo.chainId);
     const balUsd = price ? parseFloat(bal) * price : null;
     $("confirm-balance").textContent = valueWithUsd(
         truncateAmountNeverZero(bal) + " " + symbol,

src/popup/views/helpers.js

@@ -439,7 +439,7 @@ function balanceLinesForAddress(addr, trackedTokens, showZero) {
         html += balanceLine(
             t.symbol,
             bal,
-            getPrice(t.symbol),
+            getPrice(t.address),
             t.address.toLowerCase(),
         );
         seen.add(t.address.toLowerCase());
@@ -450,7 +450,7 @@ function balanceLinesForAddress(addr, trackedTokens, showZero) {
             html += balanceLine(
                 t.symbol,
                 0,
-                getPrice(t.symbol),
+                getPrice(t.address),
                 t.address.toLowerCase(),
             );
         }

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 saveEndpoint("rpcUrl", url, net.id);
-        await saveState();
-        showFlash("Saved.");
     });
 
     $("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 saveEndpoint("blockscoutUrl", url, net.id);
-        await saveState();
-        showFlash("Saved.");
     });
 
     // 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/prices.js

@@ -1,31 +1,105 @@
-// Price fetching with 5-minute cache, USD formatting, value aggregation.
+// USD prices, read from Chainlink price feeds on Ethereum mainnet, with USD
+// formatting and value aggregation. The feeds are in src/shared/tokenList.js.
 
-const { getTopTokenPrices } = require("./tokenList");
+const { Contract } = require("ethers");
+const { ETH_USD_FEED, PRICE_FEED_BY_ADDRESS } = require("./tokenList");
+const { getProvider } = require("./balances");
 const { isBelowOneMillionth } = require("./amountDisplay");
 const { networkByChainId } = require("./networks");
+const { log } = require("./log");
 
 const PRICE_CACHE_TTL = 300000; // 5 minutes
 
+// A reading older than its feed's heartbeat plus this many seconds is no price.
+const STALE_MARGIN = 1800; // 30 minutes
+
+const FEED_ABI = [
+    "function latestRoundData() view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)",
+];
+
+// USD prices: ether's under "ETH", each token's under its lowercased contract
+// address.
 const prices = {};
 let lastFetchedAt = 0;
 
-async function refreshPrices() {
+// Reads the price of ether and of each token any address holds or the user
-    // Testnet tokens have no real market value — skip price fetching
+// tracks, when that token has a feed. Mainnet only. The reads go to the RPC
-    // and clear any stale mainnet prices so the UI shows no USD values.
+// endpoint as one batched request, at most every 5 minutes. A failed read is
-    const { currentNetwork } = require("./state");
+// logged, and that token then has no price.
-    if (currentNetwork().isTestnet) {
+//
+// `signal`, passed by the popup, is aborted when the popup closes. A read that
+// fails once `signal` is aborted is not logged, because closing the popup
+// cancelled it.
+async function refreshPrices(signal) {
+    const { state, currentNetwork } = require("./state");
+    if (currentNetwork().id !== "mainnet") {
         clearPrices();
         return;
     }
     const now = Date.now();
     if (now - lastFetchedAt < PRICE_CACHE_TTL) return;
-    try {
+    const feeds = new Map([["ETH", ETH_USD_FEED]]);
-        const fetched = await getTopTokenPrices(25);
+    for (const address of heldOrTrackedTokens(state)) {
-        Object.assign(prices, fetched);
+        const feed = PRICE_FEED_BY_ADDRESS.get(address);
-        lastFetchedAt = now;
+        if (feed) feeds.set(address, feed);
-    } catch {
-        // prices stay stale on error
     }
+    // ethers sends calls made together on one provider as one batch.
+    const provider = getProvider(state.rpcUrl, state.networkId);
+    const read = {};
+    await Promise.all(
+        [...feeds].map(async ([key, feed]) => {
+            try {
+                const contract = new Contract(feed.address, FEED_ABI, provider);
+                const round = await contract.latestRoundData();
+                const price = priceFromRound(round, feed, now);
+                if (price === null) {
+                    log.warnf(
+                        "price feed reading is stale or not positive",
+                        key,
+                    );
+                    return;
+                }
+                read[key] = price;
+            } catch (e) {
+                if (signal?.aborted) return;
+                log.errorf(
+                    "price feed read failed",
+                    key,
+                    e.shortMessage || e.message,
+                );
+            }
+        }),
+    );
+    clearPrices();
+    Object.assign(prices, read);
+    lastFetchedAt = now;
+}
+
+// The lowercased contract address of each token that any address holds or
+// that the user tracks.
+function heldOrTrackedTokens(state) {
+    const addresses = new Set();
+    for (const wallet of state.wallets) {
+        for (const addr of wallet.addresses) {
+            for (const token of addr.tokenBalances || []) {
+                addresses.add(token.address.toLowerCase());
+            }
+        }
+    }
+    for (const token of state.trackedTokens || []) {
+        addresses.add(token.address.toLowerCase());
+    }
+    return addresses;
+}
+
+// The USD price in a feed's latestRoundData() result, or null when the answer
+// is not positive or was written longer ago than the feed's heartbeat plus
+// STALE_MARGIN. `now` is in milliseconds.
+function priceFromRound(round, feed, now) {
+    const ageSeconds = now / 1000 - Number(round.updatedAt);
+    if (ageSeconds > feed.heartbeat + STALE_MARGIN) return null;
+    if (round.answer <= 0n) return null;
+    return Number(round.answer) / 10 ** feed.decimals;
 }
 
 // Clear all cached prices and reset the fetch timestamp so the
@@ -37,14 +111,15 @@ function clearPrices() {
     lastFetchedAt = 0;
 }
 
-// Return the USD price for a symbol on the network with `chainId`, or on the
+// Return the USD price of the token at the contract address `token`, or of
-// active network when no chain id is given; null on testnet, on a chain id
+// ether when `token` is "ETH". The price is for the network with `chainId`, or
-// that names no network, or for a symbol with no price.
+// for the active network when no chain id is given. Returns null on testnet,
-function getPrice(symbol, chainId) {
+// on a chain id that names no network, and for a token with no price.
+function getPrice(token, chainId) {
     const { currentNetwork } = require("./state");
     const network = chainId ? networkByChainId(chainId) : currentNetwork();
     if (!network || network.isTestnet) return null;
-    return prices[symbol] || null;
+    return prices[token === "ETH" ? "ETH" : token.toLowerCase()] || null;
 }
 
 function formatUsd(amount) {
@@ -62,7 +137,7 @@ function formatUsd(amount) {
 
 // What an address is worth, as { usd, partial }.
 //
-// Prices are fetched for the top 25 tokens only, so an address can hold real
+// Only a token with a price feed has a price, so an address can hold real
 // assets this code has no price for. Adding up the priced ones and calling the
 // result the total states a number the holdings do not support: an address
 // holding nothing but unpriced tokens comes out at $0.00, which tells the user
@@ -99,8 +174,9 @@ function getAddressValue(addr) {
         // nor make it incomplete. Anything that is not a number at all is not
         // a holding this can price either, and is left to the same rule.
         if (!(tokenBal > 0)) continue;
-        if (prices[token.symbol]) {
+        const price = prices[token.address.toLowerCase()];
-            usd += tokenBal * prices[token.symbol];
+        if (price) {
+            usd += tokenBal * price;
         } else {
             partial = true;
         }

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
+// `state`, and this save writes that change. It may also change the stored
-// written; any other return lets the save go ahead.
+// 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/tokenList.js

@@ -4,12 +4,12 @@
 // Addresses are EIP-55 checksummed.
 //
 // 511 tokens.
+//
+// Below the list, USD_PRICE_FEEDS gives the Chainlink USD price feed of each
+// token that has one.
 
-const { debugFetch } = require("./log");
 const { NETWORKS } = require("./networks");
 
-const COINDESK_API = "https://data-api.coindesk.com/index/cc/v1/latest/tick";
-
 const TOKENS = [
     {
         address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
@@ -3597,6 +3597,351 @@ const TOKENS = [
     },
 ];
 
+// Chainlink price feeds on Ethereum mainnet. Each feed is a contract whose
+// latestRoundData() returns a USD price and the time the price was written.
+// The fields of a feed:
+//
+//   - address: the feed's contract
+//   - heartbeat: the most seconds the feed goes without a new price
+//   - decimals: the number of decimal places in the price
+//
+// Each feed's address and heartbeat come from Chainlink's published list of
+// mainnet feeds. Each feed was checked on mainnet by reading its description()
+// and decimals().
+
+// The ETH/USD feed, which prices ether and WETH.
+const ETH_USD_FEED = {
+    address: "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419",
+    heartbeat: 3600,
+    decimals: 8,
+};
+
+// The USD feed of each token in TOKENS that has one, keyed by the token's
+// contract address as TOKENS spells it. A token is paired with its feed by its
+// address alone, so a token that copies a listed token's symbol gets no feed.
+const USD_PRICE_FEEDS = {
+    // WETH
+    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": ETH_USD_FEED,
+    // USDT
+    "0xdAC17F958D2ee523a2206206994597C13D831ec7": {
+        address: "0x3E7d1eAB13ad0104d2750B8863b489D65364e32D",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // BNB
+    "0xB8c77482e45F1F44dE1745F52C74426C631bDD52": {
+        address: "0x14e613AC84a31f709eadbdF89C6CC390fDc9540A",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // USDC
+    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": {
+        address: "0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6",
+        heartbeat: 82800,
+        decimals: 8,
+    },
+    // USDS
+    "0xdC035D45d973E3EC169d2276DDab16f1e407384F": {
+        address: "0xfF30586cD0F29eD462364C7e81375FC0C71219b1",
+        heartbeat: 82800,
+        decimals: 8,
+    },
+    // LINK
+    "0x514910771AF9Ca656af840dff83E8264EcF986CA": {
+        address: "0x2c1d072e956AFFC0D435Cb7AC38EF18d24d9127c",
+        heartbeat: 3600,
+        decimals: 8,
+    },
+    // USDE
+    "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3": {
+        address: "0xa569d910839Ae8865Da8F8e70FfFb0cBA869F961",
+        heartbeat: 82800,
+        decimals: 8,
+    },
+    // USD1
+    "0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d": {
+        address: "0xF0d9bb015Cd7BfAb877B7156146dc09Bf461370d",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // DAI
+    "0x6B175474E89094C44Da98b954EedeAC495271d0F": {
+        address: "0xAed0c38402a5d19df6E4c03F4E2DceD6e29c1ee9",
+        heartbeat: 3600,
+        decimals: 8,
+    },
+    // PYUSD
+    "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8": {
+        address: "0x8f1dF6D7F2db73eECE86a18b4381F4707b918FB1",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // WLFI
+    "0xdA5e1988097297dCdc1f90D4dFE7909e847CBeF6": {
+        address: "0x14E5FC91Ddb3f97C33013Cc9fA74F54062Ad1Aa1",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // UNI
+    "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984": {
+        address: "0x553303d460EE0afB37EdFf9bE42922D8FF63220e",
+        heartbeat: 3600,
+        decimals: 8,
+    },
+    // PAXG
+    "0x45804880De22913dAFE09f4980848ECE6EcbAf78": {
+        address: "0x9944D86CEB9160aF5C5feB251FD671923323f8C3",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // AAVE
+    "0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9": {
+        address: "0x547a514d5e3769680Ce22B2361c10Ea13619e8a9",
+        heartbeat: 3600,
+        decimals: 8,
+    },
+    // USDF
+    "0xFa2B947eEc368f42195f24F36d2aF29f7c24CeC2": {
+        address: "0xb177857a1799aA5F7fEb5799Fdf12CbE8fdF78B1",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // USDG
+    "0xe343167631d89B6Ffc58B88d6b7fB0228795491D": {
+        address: "0x14f0737d6b705259e521EA6E9E3506AC78dBd311",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // SKY
+    "0x56072C95FAA701256059aa122697B133aDEd9279": {
+        address: "0xee10fE5E7aa92dd7b136597449c3d5813cFC5F18",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // RLUSD
+    "0x8292Bb45bf1Ee4d140127049757C2E0fF06317eD": {
+        address: "0x26C46B7aD0012cA71F2298ada567dC9Af14E7f2A",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // USDTB
+    "0xC139190F447e929f090Edeb554D95AbB8b18aC1C": {
+        address: "0x66704DAD467A7cA508B3be15865D9B9F3E186c90",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // ARB
+    "0xB50721BCf8d664c30412Cfbc6cf7a15145234ad1": {
+        address: "0x31697852a68433DbCc2Ff612c516d69E3D9bd08F",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // USD0
+    "0x73A15FeD60Bf67631dC6cd7Bc5B6e8da8190aCF5": {
+        address: "0x7e891DEbD8FA0A4Cf6BE58Ddff5a8ca174FebDCB",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // GHO
+    "0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f": {
+        address: "0x3f12643D3f6f874d39C2a4c9f2Cd6f2DbAC877FC",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // TUSD
+    "0x0000000000085d4780B73119b644AE5ecd22b376": {
+        address: "0xec746eCF986E2927Abd291a2A1716c940100f8Ba",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // EURC
+    "0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c": {
+        address: "0x04F84020Fdf10d9ee64D1dcC2986EDF2F556DA11",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // FDUSD
+    "0xc5f0f7b66764F6ec8C8Dff7BA683102295E16409": {
+        address: "0xfAA9147190c2C2cc5B8387B4f49016bDB3380572",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // CRV
+    "0xD533a949740bb3306d119CC777fa900bA034cd52": {
+        address: "0xCd627aA160A6fA45Eb793D19Ef54f5062F20f33f",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // GRT
+    "0xc944E90C64B2c07662A292be6244BDf05Cda44a7": {
+        address: "0x86cF33a451dE9dc61a2862FD94FF4ad4Bd65A5d2",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // CRVUSD
+    "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E": {
+        address: "0xEEf0C605546958c1f899b6fB336C20671f9cD49F",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // FRAX, the Legacy Frax Dollar, priced by Chainlink's FRAX / USD feed
+    "0x853d955aCEf822Db058eb8505911ED77F175b99e": {
+        address: "0xB9E1E3A9feFf48998E45Fa90847ed4D467E8BcfD",
+        heartbeat: 3600,
+        decimals: 8,
+    },
+    // ENS
+    "0xC18360217D8F7Ab5e7c516566761Ea12Ce7F9D72": {
+        address: "0x5C00128d4d1c2F4f652C267d7bcdD7aC99C16E16",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // SAND
+    "0x3845badAde8e6dFF049820680d1F14bD3903a5d0": {
+        address: "0x35E3f7E558C04cE7eEE1629258EcbbA03B36Ec56",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // AUSD
+    "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a": {
+        address: "0xB00341502DfEA6Ced8A5786b4059d29dA5E4D1FD",
+        heartbeat: 86400,
+        decimals: 18,
+    },
+    // COMP
+    "0xc00e94Cb662C3520282E6f5717214004A7f26888": {
+        address: "0xdbd020CAeF83eFd542f4De03e3cF0C28A4428bd5",
+        heartbeat: 3600,
+        decimals: 8,
+    },
+    // XCN
+    "0xA2cd3D43c775978A96BdBf12d733D5A1ED94fb18": {
+        address: "0xeb988B77b94C186053282BfcD8B7ED55142D3cAB",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // CVX
+    "0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B": {
+        address: "0xd962fC30A72A84cE50161031391756Bf2876Af5D",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // IMX
+    "0xF57e7e7C23978C3cAEC3C3548E3D615c346e79fF": {
+        address: "0xBAEbEFc1D023c0feCcc047Bff42E75F15Ff213E6",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // 1INCH
+    "0x111111111117dC0aa78b770fA6A738034120C302": {
+        address: "0xc929ad75B72593967DE83E7F7Cda0493458261D9",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // SNX
+    "0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F": {
+        address: "0xDC3EA94CD0AC27d9A86C180091e7f78C683d3699",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // DOLA
+    "0x865377367054516e17014CcdED1e7d814EDC9ce4": {
+        address: "0xE33592594f72Cc7ec8a05788be8E8455746C3a32",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // FRXUSD
+    "0xCAcd6fd266aF91b8AeD52aCCc382b4e165586E29": {
+        address: "0x9B4a96210bc8D9D55b1908B465D8B0de68B7fF83",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // YFI
+    "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e": {
+        address: "0xA027702dbb89fbd58938e4324ac03B58d812b0E1",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // RSR
+    "0x320623b8E4fF03373931769A31Fc52A4E78B5d70": {
+        address: "0x759bBC1be8F90eE6457C44abc7d443842a976d02",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // ZRX
+    "0xE41d2489571d322189246DaFA5ebDe1F4699F498": {
+        address: "0x2885d15b8Af22648b98B122b22FDF4D2a56c6023",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // FRAX, formerly FXS, priced by Chainlink's FXS / USD feed
+    "0x3432B6A60D23Ca0dFCa7761B7ab56459D9C964D0": {
+        address: "0x6Ebc52C8C1089be9eB3945C4350B68B8E4C2233f",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // SXT
+    "0xE6Bfd33F52d82Ccb5b37E16D3dD81f9FFDAbB195": {
+        address: "0x2D27d9e1b74936D8E83c4BA118F09A4c4a897f62",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // SUSHI
+    "0x6B3595068778DD592e39A122f4f5a5cF09C90fE2": {
+        address: "0xCc70F09A6CC17553b2E31954cD36E4A2d89501f7",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // RPL
+    "0xD33526068D116cE69F19A9ee46F0bd304F21A51f": {
+        address: "0x4E155eD98aFE9034b7A5962f6C84c86d869daA9d",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // USDP
+    "0x8E870D67F660D95d5be530380D0eC0bd388289E1": {
+        address: "0x09023c0DA49Aaf8fc3fA3ADF34C6A7016D38D5e3",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // SPELL
+    "0x090185f2135308BaD17527004364eBcC2D37e5F6": {
+        address: "0x8c110B94C5f1d347fAcF5E1E938AB2db60E3c9a8",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // LUSD
+    "0x5f98805A4E8be255a32880FDeC7F6728C6568bA0": {
+        address: "0x3D7aE7E594f2f2091Ad8798313450130d0Aba3a0",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // STG
+    "0xAf5191B0De278C7286d6C7CC6ab6BB8A73bA2Cd6": {
+        address: "0x7A9f34a0Aa917D438e9b6E630067062B7F8f6f3d",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // KNC
+    "0xdeFA4e8a7bcBA345F687a2f1456F5Edd9CE97202": {
+        address: "0xf8fF43E991A81e6eC886a3D281A2C6cC19aE70Fc",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+    // MUSD (the other MUSD in TOKENS has no feed)
+    "0xacA92E438df0B2401fF60dA7E4337B687a2435DA": {
+        address: "0xc90E3460424fb8ea79775089E9053113FEE34Ed0",
+        heartbeat: 86400,
+        decimals: 8,
+    },
+};
+
+// Build a map of token address (lowercased) -> its USD price feed.
+const PRICE_FEED_BY_ADDRESS = new Map();
+for (const [address, feed] of Object.entries(USD_PRICE_FEEDS)) {
+    PRICE_FEED_BY_ADDRESS.set(address.toLowerCase(), feed);
+}
+
 // Return the top N tokens from the list.
 function getTopTokens(n) {
     return TOKENS.slice(0, n);
@@ -3643,33 +3988,6 @@ for (const t of TOKENS) {
     }
 }
 
-// Fetch USD prices for the top N tokens from CoinDesk.
-// Also always includes ETH. Returns { ETH: 1234.56, LINK: 8.60, ... }.
-// n must be <= 30 (API and sanity limit).
-async function getTopTokenPrices(n) {
-    if (n > 30) {
-        throw new Error("getTopTokenPrices: n must be <= 30, got " + n);
-    }
-    const symbols = ["ETH", ...TOKENS.slice(0, n).map((t) => t.symbol)];
-    const unique = [...new Set(symbols)];
-    const instruments = unique.map((s) => s + "-USD").join(",");
-    const url =
-        COINDESK_API +
-        "?market=cadli&instruments=" +
-        instruments +
-        "&apply_mapping=true";
-    const resp = await debugFetch(url);
-    const json = await resp.json();
-    const prices = {};
-    for (const [instrument, data] of Object.entries(json.Data || {})) {
-        const symbol = instrument.split("-")[0];
-        if (data.VALUE !== undefined) {
-            prices[symbol] = data.VALUE;
-        }
-    }
-    return prices;
-}
-
 // Resolve a token symbol from multiple sources, never returning "?".
 function resolveSymbol(tokenAddress, tokenBalances, trackedTokens) {
     const lower = (tokenAddress || "").toLowerCase();
@@ -3690,7 +4008,9 @@ module.exports = {
     TOKENS,
     TOKEN_BY_ADDRESS,
     KNOWN_SYMBOLS,
+    ETH_USD_FEED,
+    USD_PRICE_FEEDS,
+    PRICE_FEED_BY_ADDRESS,
     getTopTokens,
-    getTopTokenPrices,
     resolveSymbol,
 };

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.
+// one. `info` is what tokenInfo() or permit2TokenInfo() gives for the token.
-function tokenMovedLine(label, token, sources) {
+// ETH has no address.
-    const info = tokenInfo(token, sources);
+function tokenMovedLine(label, info) {
     if (!present(info.address)) {
         return { label, value: info.symbol };
     }
     return {
         label,
-        value: info.symbol ? info.symbol + " (" + token + ")" : token,
+        value: info.symbol
-        address: token,
+            ? 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,
@@ -1240,14 +1259,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         let inputEstablished = false;
         // Whether the user pays the step that set the input side: a V2 or V3
         // swap step with `payerIsUser` true, a V4 step the user pays some of
-        // its input currency (see decodeV4Swap()), or a WRAP_ETH, whose ETH
+        // its input currency (see paidByUser in the loop), or a WRAP_ETH,
-        // comes from the transaction's value. A step paid from the router
+        // whose ETH comes from the transaction's value. A step that pays an
-        // takes nothing from the sender.
+        // ERC-20 token from the router takes none of that token from the
+        // sender.
         let inputPaidByUser = false;
-        // The recipient of a WRAP_ETH that set the input side, as written,
-        // when it is not the router; otherwise null. That WRAP_ETH pays its
-        // WETH there, not to a swap step (see the Moved to lines).
-        let wrapEthRecipient = null;
         // The last PERMIT2_PERMIT this decoder read before a step set the
         // input side, or null (see permitStands after the loop).
         let permit = null;
@@ -1297,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
+        // from the same hop, or from hops that all spend that token or all buy
-        // is never rendered against a token that did not supply it.
+        // 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
@@ -1342,7 +1359,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // What the steps take from the sender beyond the amount of the step
         // that sets the input side, as { token, amount }, in step order.
         // After the loop each joins the Amount line or gets lines of its own
-        // (see permitStands).
+        // (see permitStands). A take with `atMost` set may take less than
+        // `amount`: it never joins the Amount line, and its line reads
+        // "Up to" and the amount.
         const userPaid = [];
         // A swap step the user pays for (`payerIsUser` true) takes `amount`
         // of `token` from the sender. A V2 exact-in of ALREADY_PAID takes
@@ -1403,20 +1422,22 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // token, an UNWRAP_WETH of WETH, a WRAP_ETH of CONTRACT_BALANCE of
         // ETH, a TRANSFER, PAY_PORTION, PAY_PORTION_FULL_PRECISION or
         // ACROSS_V4_DEPOSIT_V3 of all of it, or a swap step or V4 SETTLE paid
-        // from the router (see spendFromRouter()). A V4 SETTLE of ETH paid by
+        // from the router (see spendFromRouter()). The value is the amount the
-        // the user spends the router's ETH too (see the V4_SWAP branch). The
+        // router holds, in base units, when a WRAP_ETH stated it, otherwise
-        // value is the amount the router holds, in base units, when a
+        // null.
-        // WRAP_ETH stated it, otherwise null. An UNWRAP_WETH into the router
-        // turns that amount of WETH into the same amount of ETH.
         const heldByRouter = new Map();
         const isRouter = (recipient) => {
             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 a known amount the router holds, and the steps pay
+        // counts against the amount a WRAP_ETH stated, and the steps pay all
-        // all of it once their amounts reach that one: a swap paid in ETH wraps
+        // of it once their amounts reach that one: a swap paid in ETH wraps
         // what its swap steps then spend. An amount that is not a quantity,
         // such as the null decodeV4Swap() gives a SETTLE whose payment it
         // cannot tell, or one of a token whose amount is not known, pays out
@@ -1445,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())
@@ -1597,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) {
@@ -1619,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
+                        // nothing. A check the router lets fail guarantees
-                        // step stated. A check the router lets fail guarantees
+                        // nothing either, so it is read as a zero one. A zero
-                        // nothing either, so it is read as a zero one. Any
+                        // 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;
@@ -1639,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
+                        // the last swap step determines the final output
-                        // and minimum received amount.
+                        // token. swapMinimum() gives the minimum.
-                        setOutput(i, s.tokenOut, s.amountOutMin, [s.recipient]);
+                        setOutput(
+                            i,
+                            s.tokenOut,
+                            swapMinimum(i, s.tokenOut, s.amountOutMin, [
+                                s.recipient,
+                            ]),
+                            [s.recipient],
+                        );
                         if (!s.payerIsUser) {
                             spendFromRouter(s.tokenIn, s.amountIn);
                         }
@@ -1663,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);
                         }
@@ -1695,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);
                         }
@@ -1793,9 +1895,6 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                                 w.amount,
                             );
                             inputPaidByUser = true;
-                            if (!isRouter(w.recipient)) {
-                                wrapEthRecipient = w.recipient;
-                            }
                         }
                         addPayee(w.recipient);
                         // CONTRACT_BALANCE wraps all the router's ETH.
@@ -1824,50 +1923,57 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 } else if (command === "V4_SWAP") {
                     const v4 = decodeV4Swap(inputs[i]);
                     const inputSetBefore = inputEstablished;
-                    // What the user pays the step, as decodeV4Swap() gives
+                    // V4Router pays a SETTLE of ETH from the router's own
-                    // it, less the ETH the router already holds (below).
+                    // ETH, whichever payer the SETTLE names. The router holds
-                    // Empty when the step cannot be read.
+                    // the transaction's value, and any ETH an earlier step
-                    const paidByUser = [];
+                    // left it (see heldByRouter). So the user also pays a
+                    // SETTLE of ETH that names the router as payer. The user
+                    // pays all of its amount when the router holds no other
+                    // ETH, and up to its amount otherwise. CONTRACT_BALANCE
+                    // pays all the router holds, an amount the calldata does
+                    // not state.
+                    const routerHeldEth = heldByRouter.has(
+                        "0x0000000000000000000000000000000000000000",
+                    );
+                    const ethFromRouter = (v4?.settledFromRouter ?? [])
+                        .filter(
+                            (s) =>
+                                s.currency ===
+                                "0x0000000000000000000000000000000000000000",
+                        )
+                        .map((s) => ({
+                            currency: s.currency,
+                            amount:
+                                s.amount === CONTRACT_BALANCE ? null : s.amount,
+                        }));
+                    // What the user pays the step: what decodeV4Swap() says,
+                    // and the ETH of each SETTLE from the router of a known
+                    // amount when the router holds no other ETH.
+                    const paidByUser = v4
+                        ? v4.paidByUser.concat(
+                              routerHeldEth
+                                  ? []
+                                  : ethFromRouter.filter((s) =>
+                                        present(s.amount),
+                                    ),
+                          )
+                        : [];
                     if (v4) {
                         // Each SETTLE paid from the router spends the amount
                         // decodeV4Swap() says it pays.
                         for (const s of v4.settledFromRouter) {
                             spendFromRouter(s.currency, s.amount);
                         }
-                        // V4Router pays ETH from the router's own ETH,
-                        // whoever a SETTLE names as payer. So ETH the router
-                        // holds from an earlier step pays first for the ETH
-                        // the user would pay the step. The user pays only the
-                        // rest. When this decoder does not know how much ETH
-                        // the router holds, or how much the user would pay,
-                        // it counts the router as paying all of that ETH.
-                        for (const p of v4.paidByUser) {
-                            if (
-                                p.currency !==
-                                    "0x0000000000000000000000000000000000000000" ||
-                                !heldByRouter.has(p.currency)
-                            ) {
-                                paidByUser.push(p);
-                                continue;
-                            }
-                            const held = heldByRouter.get(p.currency);
-                            if (
-                                typeof held === "bigint" &&
-                                typeof p.amount === "bigint" &&
-                                p.amount > held
-                            ) {
-                                paidByUser.push({
-                                    currency: p.currency,
-                                    amount: p.amount - held,
-                                });
-                            }
-                            spendFromRouter(p.currency, p.amount);
-                        }
                         for (const t of v4.takes) {
                             if (!isHop(i, t.currency, t.recipient)) {
                                 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;
@@ -1887,9 +1993,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         commandNames[i] += " (could not be decoded)";
                     }
                     // The step's amount, if it sets the input side: what the
-                    // user pays it of its input currency (see paidByUser),
+                    // user pays it of its input currency, or, when the user
-                    // or, when the user pays none of it, what its swap
+                    // pays none of it, what its swap actions spend of it,
-                    // actions spend of it, whoever pays that.
+                    // whoever pays that.
                     const paidIn = paidByUser.find(
                         (p) => p.currency === v4.tokenIn,
                     );
@@ -1916,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;
@@ -1948,6 +2059,22 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         if (setInputHere && p === paidIn) continue;
                         addUserPaid(p.currency, p.amount);
                     }
+                    // A SETTLE of ETH from the router that `paidByUser` leaves
+                    // out is a take of its own, even on the step that sets
+                    // the input side. Either this decoder does not know its
+                    // amount, or ETH an earlier step left in the router may
+                    // pay part of that amount (see userPaid).
+                    for (const p of ethFromRouter) {
+                        if (!present(p.amount)) {
+                            addUserPaid(p.currency, null);
+                        } else if (routerHeldEth) {
+                            userPaid.push({
+                                token: p.currency,
+                                amount: p.amount,
+                                atMost: true,
+                            });
+                        }
+                    }
                     if (!v4 || v4.settleUnread) {
                         spentUnread();
                     }
@@ -1994,23 +2121,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         addPayee(u.recipient);
                         // It pays out all the router's WETH, as ETH. Into the
                         // router, the router then holds as ETH the WETH a
-                        // step paid it. That amount is known when the router
+                        // step paid it.
-                        // held a known amount of WETH and no ETH before.
+                        const heldWeth = WETH_ADDRESSES.some((w) =>
-                        const heldWeth = WETH_ADDRESSES.filter((w) =>
                             heldByRouter.has(w),
                         );
-                        const ethAmount =
+                        WETH_ADDRESSES.forEach((w) => heldByRouter.delete(w));
-                            heldWeth.length === 1 &&
+                        if (isRouter(u.recipient) && heldWeth) {
-                            !heldByRouter.has(
-                                "0x0000000000000000000000000000000000000000",
-                            )
-                                ? heldByRouter.get(heldWeth[0])
-                                : null;
-                        heldWeth.forEach((w) => heldByRouter.delete(w));
-                        if (isRouter(u.recipient) && heldWeth.length > 0) {
                             heldByRouter.set(
                                 "0x0000000000000000000000000000000000000000",
-                                ethAmount,
+                                null,
                             );
                         }
                     } else {
@@ -2061,10 +2180,10 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // The total is what the steps take of Token In: the amount of the
         // step that set the input side, with each later take of that token
         // added to it while both are quantities. A take that cannot be added,
-        // being of another token or coming after an amount that is not a
+        // being of another token, coming after an amount that is not a
-        // quantity (a V4 open delta, ALREADY_PAID, or none stated), gets
+        // quantity (a V4 open delta, ALREADY_PAID, or none stated), or having
-        // lines of its own. One whose amount is not known also leaves the
+        // `atMost` set, gets lines of its own. One whose amount is not known
-        // total unknown, with no figure.
+        // also leaves the total unknown, with no figure.
         //
         // A PERMIT2_PERMIT names Token In only when its amount stands as the
         // Amount figure in place of the total, which it does only in the
@@ -2080,12 +2199,14 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // it may take more. A later permit or batch, or a later step this
         // decoder did not read, may raise what Permit2 lets the router take.
         // Every other PERMIT2_PERMIT leaves Token In and the Amount line as
-        // they read with no permit, and gets lines of its own below. A step
+        // they read with no permit, and gets lines of its own below. A permit
-        // that may take from the sender what this decoder did not read leaves
+        // on the zero address never stands as the Amount figure, because
-        // no figure, permit or not (see spentUnread()), and so do a permit
+        // Permit2 has no allowance of ETH. A step that may take from the
-        // or batch whose input it cannot read (see permitUnread()) and an
+        // sender what this decoder did not read leaves no figure, permit or
-        // allowance of Token In to another spender (see toAnotherSpender). An
+        // not (see spentUnread()), and so do a permit or batch whose input it
-        // EXECUTE_SUB_PLAN step leaves both sides unknown (below).
+        // cannot read (see permitUnread()) and an allowance of Token In to
+        // another spender (see toAnotherSpender). An EXECUTE_SUB_PLAN step
+        // leaves both sides unknown (below).
         const stepCommands = Array.from(
             commandsBytes,
             (b) => commands[b & commandTypeMask],
@@ -2095,27 +2216,25 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             stepCommands.filter((c) => c === "PERMIT2_PERMIT").length === 1 &&
             !stepCommands.includes("PERMIT2_PERMIT_BATCH") &&
             sameAddress(permit.spender, toAddress) &&
+            permit.token !== "0x0000000000000000000000000000000000000000" &&
             !permit.allowedToFail &&
             permit.beforeEveryTake &&
             !stepsUnread.some((step) => step > permit.step);
         // What the steps take that the Amount line does not give, as
-        // { token, amount, recipient }. A null token is a step this decoder
+        // { token, amount }. A null token is a step this decoder did not read
-        // did not read (see spentUnread()), or a token it does not know. Only
+        // (see spentUnread()), or a token it does not know.
-        // the take of a WRAP_ETH that pays elsewhere has a recipient (see
-        // wrapEthRecipient).
         const spentFromSender = [];
         let total = null;
-        // The takes from the sender that `total` adds up, each a quantity, in
+        // The takes from the sender that `total` adds up, each a quantity, as
-        // the shape of `spentFromSender`. When there is no Amount line, each
+        // { token, amount }. When there is no Amount line, each gets lines of
-        // gets lines of its own (see below). The amount of a step that set
+        // its own (see below). The amount of the step that set the input side
-        // the input side and is paid from the router counts in `total` but is
+        // counts in `total` whoever pays that step. That amount is among them
-        // not among them.
+        // only when the user pays the step (see inputPaidByUser).
         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
-        // some of its input token: paid from the router, it takes nothing
+        // some of its input token.
-        // from the sender.
         const hasFirstTake =
             inputEstablished && (present(inputAmount) || inputPaidByUser);
         // The take of the step that set the input side, when the total
@@ -2124,11 +2243,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         if (!permitStands || sameAddress(inputToken, permit.token)) {
             total = inputAmount;
             if (typeof inputAmount === "bigint" && inputPaidByUser) {
-                inTotal.push({
+                inTotal.push({ token: inputToken, amount: inputAmount });
-                    token: inputToken,
-                    amount: inputAmount,
-                    recipient: wrapEthRecipient,
-                });
             }
             if (hasFirstTake && !present(inputAmount)) {
                 firstTakeUnstated = { token: inputToken, amount: null };
@@ -2136,11 +2251,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         } else if (hasFirstTake) {
             // The step that set the input side spent a token other than the
             // permit's, or one not known, so its amount gets lines of its own.
-            spentFromSender.push({
+            spentFromSender.push({ token: inputToken, amount: inputAmount });
-                token: inputToken,
-                amount: inputAmount,
-                recipient: wrapEthRecipient,
-            });
         }
         if (permitStands) inputToken = permit.token;
         for (const t of userPaid) {
@@ -2149,7 +2260,8 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             if (
                 ofTokenIn &&
                 typeof total === "bigint" &&
-                typeof t.amount === "bigint"
+                typeof t.amount === "bigint" &&
+                !t.atMost
             ) {
                 total += t.amount;
                 inTotal.push(t);
@@ -2252,8 +2364,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // V2's already-paid zero, neither of which is a quantity at all (see
         // OPEN_DELTA and ALREADY_PAID), and an unbounded permit. Those two
         // tests come first — the sentinels are not bigints and cannot be
-        // compared with one.
+        // compared with one. `atMost` marks an amount that is only the most a
-        const spentText = (amount, info) => {
+        // take may be (see userPaid).
+        const spentText = (amount, info, atMost) => {
             if (amount === OPEN_DELTA) {
                 return { raw: OPEN_DELTA_AMOUNT, display: OPEN_DELTA_AMOUNT };
             }
@@ -2266,7 +2379,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             if (amount >= MAX_UINT160) {
                 return { raw: "Unlimited", display: "Unlimited" };
             }
-            if (hasV2OrV3ExactOut) {
+            if (hasV2OrV3ExactOut || atMost) {
                 // A V2 or V3 exact-out swap spends at most this figure,
                 // whichever steps gave it (an amountInMax, the WRAP_ETH of a
                 // swap paid in ETH, a permit, or several steps' total), so it
@@ -2293,17 +2406,19 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // A null token in `spentFromSender`, a step this decoder did not read
         // or a token it does not know, and an allowance to another spender
         // that may be of Token In, leave no Amount figure, which may then be
-        // too low. With no Amount line, each take the total adds up gets
+        // too low. An allowance of the zero address is never one of Token In,
-        // lines of its own, first, so that every amount this decoder read is
+        // because Permit2 has no allowance of ETH. With no Amount line, each
-        // shown.
+        // 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)) &&
             toAnotherSpender.every(
                 (p) =>
-                    present(p.token) &&
+                    p.token === "0x0000000000000000000000000000000000000000" ||
-                    present(inputToken) &&
+                    (present(p.token) &&
-                    !sameAddress(p.token, inputToken),
+                        present(inputToken) &&
+                        !sameAddress(p.token, inputToken)),
             )
         ) {
             const amount = spentText(inputAmount, inInfo);
@@ -2319,44 +2434,35 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // What steps take from the sender beyond the Amount line, in the shape
         // of the lines below for a PERMIT2_TRANSFER_FROM. An amount this
         // decoder does not know is said so, and a step it did not read gets
-        // that one line alone. A take with no recipient goes to the swap step
+        // that one line alone.
-        // that spends it. A take with a recipient goes there, and MSG_SENDER
-        // there is the sender.
         for (const s of spentFromSender) {
             details.push({
                 label: "Moved from the sender",
                 value: present(s.amount)
-                    ? spentText(s.amount, tokenInfo(s.token, sources)).display
+                    ? spentText(s.amount, tokenInfo(s.token, sources), s.atMost)
+                          .display
                     : UNDECODED_CURRENCY,
             });
             if (present(s.token)) {
-                details.push(tokenMovedLine("Token moved", s.token, sources));
+                details.push(
-                if (!present(s.recipient)) {
+                    tokenMovedLine("Token moved", tokenInfo(s.token, sources)),
-                    details.push({
+                );
-                        label: "Moved to",
+                details.push({
-                        value: "The swap step that spends it",
+                    label: "Moved to",
-                    });
+                    value: "The swap step that spends it",
-                } else if (s.recipient.toLowerCase() === MSG_SENDER) {
+                });
-                    details.push({ label: "Moved to", value: "The sender" });
-                } else {
-                    details.push({
-                        label: "Moved to",
-                        value: s.recipient,
-                        address: s.recipient,
-                    });
-                }
             }
         }
 
         // 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))
+                value: amountText(m.amount, info).display,
-                    .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 }
@@ -2386,15 +2492,15 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 });
                 continue;
             }
+            const info = permit2TokenInfo(p.token, sources);
             details.push({
                 label: "Permit2 allowance",
                 value:
                     p.amount >= MAX_UINT160
                         ? "Unlimited"
-                        : amountText(p.amount, tokenInfo(p.token, sources))
+                        : amountText(p.amount, info).display,
-                              .display,
             });
-            details.push(tokenMovedLine("Allowance token", p.token, sources));
+            details.push(tokenMovedLine("Allowance token", info));
             details.push({
                 label: "Allowance spender",
                 value: p.spender,
@@ -2452,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:
@@ -2460,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(
+            paidTo.push(tokenMovedLine("Token moved into the router", info));
-                tokenMovedLine("Token moved into the router", m.token, sources),
-            );
         }
         if (outputHeld) {
             paidTo.push({ label: "Paid to", value: STAYS_IN_ROUTER });
@@ -2479,8 +2583,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             paidTo.push(
                 tokenMovedLine(
                     "Token moved into the router",
-                    getAddress(token),
+                    tokenInfo(getAddress(token), sources),
-                    sources,
                 ),
             );
         }

tests/addressValue.test.js

@@ -1,9 +1,9 @@
 // The USD total of an address that holds something this build cannot price
 // (issue #261).
 //
-// Prices exist for the top 25 tokens only, so an address can hold real assets
+// Only a token with a price feed has a price, so an address can hold real
-// with no price attached. Summing what is priced and printing the result as
+// assets with no price attached. Summing what is priced and printing the result
-// the total says "$0.00" for an address holding nothing but unpriced tokens —
+// as the total says "$0.00" for an address holding nothing but unpriced tokens —
 // worth-nothing and worth-an-unknown-amount collapsed into one number, in the
 // direction that matters. The two are separate facts here, the same way an
 // absent holders_count is not a count of zero.
@@ -63,7 +63,7 @@ const PARTLY_PRICED = {
 beforeEach(() => {
     clearPrices();
     prices.ETH = 2000;
-    prices.USDC = 1;
+    prices[USDC] = 1;
     state.wallets = [];
     state.trackedTokens = [];
     state.showZeroBalanceTokens = false;

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/confirmTxNetworkSwitch.test.js

@@ -226,6 +226,7 @@ const PRIVATE_KEY = "0x" + "11".repeat(32);
 const HOLDER = new Wallet(PRIVATE_KEY).address;
 const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
 const TOKEN = "0x7070707070707070707070707070707070707070";
+const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
 const PASSWORD = "correct horse battery staple";
 
 function el(id) {
@@ -318,7 +319,7 @@ async function switchReopenAndGoBack(reviewedOn, switchedTo) {
     setBackRenderer(makeBackRenderer(state, { confirmTx }));
     confirmTx.init({});
     prices.ETH = 2000;
-    prices.USDC = 1;
+    prices[USDC] = 1;
     mockNode.asked = [];
     global.fetch.mockClear();
     goBack();
@@ -641,7 +642,7 @@ describe.each([
         test("of an ERC-20 token, links the token contract to that network's explorer and prices the token by that network", async () => {
             mockNode.tokenUnits[reviewedOn] = 50000000n;
             await review(reviewedOn, {
-                token: TOKEN,
+                token: USDC,
                 tokenSymbol: "USDC",
                 tokenDecimals: 6,
                 amount: "10",
@@ -652,7 +653,7 @@ describe.each([
                 "ERC-20 token transfer (USDC)",
             );
             expect(el("confirm-token-contract").innerHTML).toContain(
-                `href="${explorerUrl}/address/${TOKEN}"`,
+                `href="${explorerUrl}/address/${USDC}"`,
             );
             expect(el("confirm-amount").textContent).toBe(
                 "10.0000 USDC" + usdOn(reviewedOn, "$10.00"),

tests/deleteAddress.test.js

@@ -153,7 +153,7 @@ describe("the balance warning on the removal confirmation", () => {
 
     test("the USD total is shown when prices are known", () => {
         prices.ETH = 2000;
-        prices.USDC = 1;
+        prices[USDC] = 1;
         expect(balanceWarningHtml(TOKEN_ONLY)).toContain("Total: $2,500.00");
         expect(balanceWarningHtml(ETH_ONLY)).toContain("Total: $3,000.00");
     });

tests/e2e/dapp.js

@@ -43,12 +43,15 @@ const GAS_PRICE_WEI = BASE_FEE_WEI + PRIORITY_FEE_WEI;
 
 const STUB_BLOCK_NUMBER = 21000000;
 
-// A 32-byte zero word, returned for every eth_call. It is what makes ethers'
+// A 32-byte zero word, returned for every eth_call but a price feed's
+// latestRoundData() (see rpcResult() below). It is what makes ethers'
 // ENS reverse lookup resolve to "no resolver set" instead of throwing, and a
 // throw there reaches the console through src/shared/log.js, which fails the
 // run on its own.
 const ZERO_WORD = "0x" + "0".repeat(64);
 
+const SELECTOR_LATEST_ROUND_DATA = "0xfeaf968c";
+
 // One ETH, so the popup's balance lines render something and the wallet does
 // not look empty on the approval screen.
 const STUB_BALANCE_WEI = 10n ** 18n;
@@ -111,6 +114,15 @@ function rpcResult(req, state) {
         return latestBlock();
     }
 
+    // A price feed's latestRoundData() gets five zero words, as in network.js:
+    // a price of zero, which the wallet counts as no price.
+    const data = String(
+        (req.params && req.params[0] && req.params[0].data) || "",
+    );
+    if (method === "eth_call" && data.startsWith(SELECTOR_LATEST_ROUND_DATA)) {
+        return "0x" + "0".repeat(64 * 5);
+    }
+
     if (Object.prototype.hasOwnProperty.call(RPC_RESULTS, method)) {
         return RPC_RESULTS[method];
     }

tests/e2e/network.js

@@ -251,8 +251,13 @@ const SELECTOR_DECIMALS = "0x313ce567";
 const SELECTOR_SYMBOL = "0x95d89b41";
 const SELECTOR_NAME = "0x06fdde03";
 const SELECTOR_BALANCE_OF = "0x70a08231";
+const SELECTOR_LATEST_ROUND_DATA = "0xfeaf968c";
 
-// Every eth_call still answers with a zero word except decimals(), symbol(),
+// On any contract, a latestRoundData() call is answered with five zero words.
+// That is a round with a price of zero, which the wallet counts as no
+// price. So no screen shows a USD value beside the amounts the tests compare.
+//
+// Every other eth_call answers with a zero word except decimals(), symbol(),
 // name() and balanceOf() on the stub token. The wallet reads decimals() back
 // at signing time to compare with the scale the confirmation screen rendered
 // (issue #305). Adding the token by its contract address reads the first three
@@ -273,6 +278,9 @@ function ethCallResult(req, opts) {
     if (!call || typeof call !== "object") return ZERO_WORD;
     const data = String(call.data || call.input || "").toLowerCase();
     const to = String(call.to || "").toLowerCase();
+    if (data.startsWith(SELECTOR_LATEST_ROUND_DATA)) {
+        return "0x" + "0".repeat(64 * 5);
+    }
     if (to !== STUB_TOKEN.address) return ZERO_WORD;
     if (data.startsWith(SELECTOR_DECIMALS)) {
         return word(opts.tokenDecimalsOverride ?? STUB_TOKEN.decimals);
@@ -764,11 +772,6 @@ async function installNetworkStubs(ctx, opts) {
             }
         }
 
-        // CoinDesk price tick
-        if (url.hostname.endsWith("coindesk.com")) {
-            return jsonResponse(route, { Data: {} });
-        }
-
         // The interception canary's own request. Answered with nothing: what
         // is being observed is that it arrived here at all.
         if (url.href === WORKER_PROBE_URL) {

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/priceFeeds.test.js

@@ -0,0 +1,272 @@
+// USD prices are read from Chainlink price feeds on mainnet, through the RPC
+// endpoint (https://git.eeqj.de/sneak/AutistMask/issues/525).
+//
+// The real refreshPrices() runs against a fake JSON-RPC node, answered through
+// ethers' own request hook. The hook also records the body of every HTTP
+// request, so a test can count them.
+
+// prices.js pulls in state.js, which reads chrome.storage.local at load.
+globalThis.chrome = {
+    storage: { local: { get: async () => ({}), set: async () => {} } },
+};
+
+const { AbiCoder, FetchRequest } = require("ethers");
+const {
+    prices,
+    refreshPrices,
+    clearPrices,
+    getPrice,
+    getAddressValue,
+} = require("../src/shared/prices");
+const { state } = require("../src/shared/state");
+const {
+    TOKENS,
+    ETH_USD_FEED,
+    USD_PRICE_FEEDS,
+    PRICE_FEED_BY_ADDRESS,
+} = require("../src/shared/tokenList");
+
+const RPC_URL = "https://rpc.example.invalid";
+const NOW = Date.UTC(2026, 9, 27, 12, 0, 0);
+const NOW_SECONDS = NOW / 1000;
+
+const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
+const LINK = "0x514910771af9ca656af840dff83e8264ecf986ca";
+const DAI = "0x6b175474e89094c44da98b954eedeac495271d0f";
+// A token at an address of its own that calls itself USDC.
+const FAKE_USDC = "0x9999999999999999999999999999999999999999";
+
+const ETH_FEED = ETH_USD_FEED.address.toLowerCase();
+const USDC_FEED = PRICE_FEED_BY_ADDRESS.get(USDC).address.toLowerCase();
+const LINK_FEED = PRICE_FEED_BY_ADDRESS.get(LINK).address.toLowerCase();
+const DAI_FEED = PRICE_FEED_BY_ADDRESS.get(DAI).address.toLowerCase();
+
+// What each feed answers, by its lowercased address: the price in the feed's
+// own units and the time it was written. A feed that is not here makes the
+// call fail.
+let rounds;
+// The parsed body of every HTTP request the node received.
+let requests;
+let logged;
+
+function round(answer, updatedAt = NOW_SECONDS) {
+    return { answer, updatedAt };
+}
+
+// One JSON-RPC answer, to a latestRoundData() call.
+function reply(req) {
+    const envelope = { jsonrpc: "2.0", id: req.id };
+    const answer = rounds[req.params[0].to.toLowerCase()];
+    if (!answer) {
+        return {
+            ...envelope,
+            error: { code: -32000, message: "fixture: read failed" },
+        };
+    }
+    return {
+        ...envelope,
+        result: AbiCoder.defaultAbiCoder().encode(
+            ["uint80", "int256", "uint256", "uint256", "uint80"],
+            [1, answer.answer, answer.updatedAt, answer.updatedAt, 1],
+        ),
+    };
+}
+
+// The feed addresses one HTTP request read, sorted.
+function feedsRead(body) {
+    return [body]
+        .flat()
+        .map((req) => req.params[0].to.toLowerCase())
+        .sort();
+}
+
+// One address that holds `held`, a list of [contract address, symbol].
+function holdTokens(held) {
+    state.wallets = [
+        {
+            addresses: [
+                {
+                    address: "0x" + "a".repeat(40),
+                    balance: "1.0",
+                    tokenBalances: held.map(([address, symbol]) => ({
+                        address,
+                        symbol,
+                        balance: "10.0",
+                    })),
+                },
+            ],
+        },
+    ];
+}
+
+beforeEach(() => {
+    clearPrices();
+    state.networkId = "mainnet";
+    state.rpcUrl = RPC_URL;
+    state.wallets = [];
+    state.trackedTokens = [];
+    rounds = { [ETH_FEED]: round(2000n * 10n ** 8n) };
+    requests = [];
+    logged = [];
+    jest.spyOn(Date, "now").mockReturnValue(NOW);
+    for (const level of ["error", "warn"]) {
+        jest.spyOn(console, level).mockImplementation((...args) => {
+            logged.push(args.map(String).join(" "));
+        });
+    }
+    FetchRequest.registerGetUrl(async (req) => {
+        const body = JSON.parse(Buffer.from(req.body).toString("utf8"));
+        requests.push(body);
+        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)),
+        };
+    });
+});
+
+afterEach(() => {
+    FetchRequest.registerGetUrl(FetchRequest.createGetUrlFunc());
+    jest.restoreAllMocks();
+    clearPrices();
+});
+
+describe("refreshPrices", () => {
+    test("reads ETH and each held or tracked token that has a feed in one HTTP request", async () => {
+        holdTokens([
+            [USDC, "USDC"],
+            [LINK, "LINK"],
+        ]);
+        state.trackedTokens = [{ address: DAI, symbol: "DAI", decimals: 18 }];
+        rounds[USDC_FEED] = round(10n ** 8n);
+        rounds[LINK_FEED] = round(1150000000n);
+        rounds[DAI_FEED] = round(99990000n);
+
+        await refreshPrices();
+
+        expect(requests).toHaveLength(1);
+        expect(feedsRead(requests[0])).toEqual(
+            [ETH_FEED, USDC_FEED, LINK_FEED, DAI_FEED].sort(),
+        );
+        expect(getPrice("ETH")).toBe(2000);
+        expect(getPrice(USDC)).toBe(1);
+        expect(getPrice(LINK)).toBe(11.5);
+        expect(getPrice(DAI)).toBe(0.9999);
+    });
+
+    test("reads again only once 5 minutes have passed", async () => {
+        await refreshPrices();
+        Date.now.mockReturnValue(NOW + 299999);
+        await refreshPrices();
+        expect(requests).toHaveLength(1);
+
+        Date.now.mockReturnValue(NOW + 300000);
+        rounds[ETH_FEED] = round(2100n * 10n ** 8n, NOW_SECONDS + 300);
+        await refreshPrices();
+        expect(requests).toHaveLength(2);
+        expect(getPrice("ETH")).toBe(2100);
+    });
+
+    test("on Sepolia, reads nothing and keeps no price", async () => {
+        await refreshPrices();
+        expect(getPrice("ETH")).toBe(2000);
+
+        state.networkId = "sepolia";
+        await refreshPrices();
+        expect(requests).toHaveLength(1);
+        expect(Object.keys(prices)).toEqual([]);
+    });
+});
+
+describe("pairing by contract address", () => {
+    test("a token that copies a bundled token's symbol gets no price", async () => {
+        holdTokens([
+            [USDC, "USDC"],
+            [FAKE_USDC, "USDC"],
+        ]);
+        rounds[USDC_FEED] = round(10n ** 8n);
+
+        await refreshPrices();
+
+        expect(feedsRead(requests[0])).toEqual([ETH_FEED, USDC_FEED].sort());
+        expect(getPrice(USDC)).toBe(1);
+        expect(getPrice(FAKE_USDC)).toBeNull();
+        // 1 ETH and 10 real USDC are priced; the 10 look-alikes are not.
+        expect(getAddressValue(state.wallets[0].addresses[0])).toEqual({
+            usd: 2010,
+            partial: true,
+        });
+    });
+});
+
+describe("freshness", () => {
+    test("a reading older than its feed's heartbeat plus 30 minutes is no price", async () => {
+        const heartbeatAgo =
+            NOW_SECONDS - PRICE_FEED_BY_ADDRESS.get(USDC).heartbeat;
+        holdTokens([[USDC, "USDC"]]);
+
+        rounds[USDC_FEED] = round(10n ** 8n, heartbeatAgo - 1800 - 1);
+        await refreshPrices();
+        expect(getPrice(USDC)).toBeNull();
+
+        clearPrices();
+        rounds[USDC_FEED] = round(10n ** 8n, heartbeatAgo - 1800);
+        await refreshPrices();
+        expect(getPrice(USDC)).toBe(1);
+    });
+
+    test.each([0n, -1n])("an answer of %s is no price", async (answer) => {
+        rounds[ETH_FEED] = round(answer);
+        await refreshPrices();
+        expect(getPrice("ETH")).toBeNull();
+    });
+});
+
+describe("a failed read", () => {
+    test("leaves the token with no price and is logged with its error", async () => {
+        holdTokens([[USDC, "USDC"]]);
+        rounds[USDC_FEED] = round(10n ** 8n);
+        await refreshPrices();
+        expect(getPrice(USDC)).toBe(1);
+
+        Date.now.mockReturnValue(NOW + 300000);
+        delete rounds[USDC_FEED];
+        await refreshPrices();
+
+        expect(getPrice(USDC)).toBeNull();
+        expect(getPrice("ETH")).toBe(2000);
+        expect(
+            logged.some(
+                (line) =>
+                    line.includes("price feed read failed") &&
+                    line.includes(USDC),
+            ),
+        ).toBe(true);
+    });
+
+    test("an HTTP error is logged with its status", async () => {
+        FetchRequest.registerGetUrl(async () => ({
+            statusCode: 401,
+            statusMessage: "Unauthorized",
+            headers: { "content-type": "text/plain" },
+            body: Buffer.from("API key required"),
+        }));
+
+        await refreshPrices();
+
+        expect(getPrice("ETH")).toBeNull();
+        expect(logged.some((line) => line.includes("401"))).toBe(true);
+    });
+});
+
+describe("the feed table", () => {
+    test("names each token by its address as the bundled list spells it", () => {
+        const listed = new Set(TOKENS.map((t) => t.address));
+        const unlisted = Object.keys(USD_PRICE_FEEDS).filter(
+            (address) => !listed.has(address),
+        );
+        expect(unlisted).toEqual([]);
+    });
+});

tests/stateRecovery.test.js

@@ -23,6 +23,9 @@
 // version field, and showing those users a wipe prompt would be a worse defect
 // than the one being fixed. It is migrated in place and keeps working.
 
+const fs = require("fs");
+const path = require("path");
+
 const {
     bootPopup,
     cleanupPopup,
@@ -148,6 +151,29 @@ describe("the destructive reset on the recovery screen", () => {
     });
 });
 
+// A key or xprv wallet has no recovery phrase, so the erase warning names all
+// three backups (https://git.eeqj.de/sneak/AutistMask/issues/593). The boot
+// harness holds no static text, so this reads the markup itself.
+describe("the erase warning on the recovery screen", () => {
+    test("names the recovery phrase, the private key and the extended private key", () => {
+        const html = fs.readFileSync(
+            path.join(__dirname, "..", "src", "popup", "index.html"),
+            "utf8",
+        );
+        const start = html.indexOf('id="view-state-recovery"');
+        const end = html.indexOf('id="btn-state-recovery-reset"', start);
+        const screenText = html
+            .slice(start, end)
+            .replace(/<[^>]*>/g, " ")
+            .replace(/\s+/g, " ");
+
+        expect(screenText).toContain(
+            "If you kept a copy of a wallet's recovery phrase, private key or " +
+                "extended private key, you can add that wallet again.",
+        );
+    });
+});
+
 describe("a popup already open when the stored profile becomes unreadable", () => {
     // https://git.eeqj.de/sneak/AutistMask/issues/373. The popup used to stay
     // on the wallet list with the last good balances, and only a reopen

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

@@ -2424,113 +2424,6 @@ describe("uniswap decoder", () => {
             expect(linesBetweenTokens(result)).toEqual(lines);
         });
 
-        // https://git.eeqj.de/sneak/AutistMask/issues/665 — a WRAP_ETH that
-        // sets the input side and pays its WETH to anyone but the router
-        // names that recipient on its Moved to line. On next each row read
-        // The swap step that spends it.
-        const ONE_ETH = 1000000000000000000n;
-        const MSG_SENDER = "0x0000000000000000000000000000000000000001";
-        // The lines of a WRAP_ETH of 1 ETH whose Moved to line reads `to`.
-        const wrapLines = (to) => [
-            ["Moved from the sender", "1.0000 ETH"],
-            ["Token moved", "ETH"],
-            ["Moved to", to],
-        ];
-        test.each([
-            {
-                kind: "a WRAP_ETH of 1 ETH to another address, then an EXECUTE_SUB_PLAN",
-                commands: [0x0b, 0x21],
-                inputs: [encodeWrapEth(OTHER_ADDR, ONE_ETH), SUB_PLAN],
-                lines: [
-                    ...wrapLines(OTHER_ADDR),
-                    ["Moved from the sender", UNDECODED],
-                ],
-            },
-            {
-                kind: "a WRAP_ETH of 1 ETH to address(1), then an EXECUTE_SUB_PLAN",
-                commands: [0x0b, 0x21],
-                inputs: [encodeWrapEth(MSG_SENDER, ONE_ETH), SUB_PLAN],
-                lines: [
-                    ...wrapLines("The sender"),
-                    ["Moved from the sender", UNDECODED],
-                ],
-            },
-            {
-                kind: "a PERMIT2_PERMIT of 5,000 USDT to the router, a WRAP_ETH of 1 ETH to another address, then a V3 exact-in of 600 USDT",
-                commands: [0x0a, 0x0b, 0x00],
-                inputs: [
-                    encodePermit2(USDT_ADDR, 5000000000n, ROUTER_ADDR),
-                    encodeWrapEth(OTHER_ADDR, ONE_ETH),
-                    V3_600,
-                ],
-                lines: [["Amount", "5000.0000 USDT"], ...wrapLines(OTHER_ADDR)],
-            },
-        ])("$kind", ({ commands, inputs, lines }) => {
-            const result = decodeSteps(commands, inputs);
-            expect(linesBetweenTokens(result)).toEqual(lines);
-        });
-
-        // https://git.eeqj.de/sneak/AutistMask/issues/665 — V4Router pays ETH
-        // from the router's own ETH, whoever a SETTLE names as payer. ETH the
-        // router holds from an UNWRAP_WETH into it pays first, so the sender
-        // pays only the ETH beyond it. On next each row also took the V4
-        // step's whole ETH from the sender: 1 ETH more in the first two, and
-        // 1.5 ETH in the last.
-        const unwrapIntoRouter = encodeWrapEth(ROUTER_ADDR, 0n); // UNWRAP_WETH, same encoding
-        // A V4 step swapping `amount` of ETH for USDC, with a SETTLE of
-        // OPEN_DELTA by the user.
-        const v4EthForUsdc = (amount) =>
-            encodeV4Swap(
-                new Uint8Array([
-                    V4_SWAP_EXACT_IN_SINGLE_ID,
-                    V4_SETTLE_ID,
-                    V4_TAKE_ALL_ID,
-                ]),
-                [
-                    encodeV4ExactInSingle(ZERO_ADDR, USDC_ADDR, amount, 1n),
-                    settle(ZERO_ADDR, 0n, true),
-                    encodeV4TakeAll(USDC_ADDR, 0n),
-                ],
-            );
-        test.each([
-            {
-                kind: "a V3 exact-in of 600 USDT for WETH paid to the router, an UNWRAP_WETH into the router, then a V4 swap of 1 ETH that the user settles",
-                commands: [0x00, 0x0c, 0x10],
-                inputs: [
-                    encodeV3SwapExactIn(ROUTER_ADDR, USDT_600, 1n, [
-                        USDT_ADDR,
-                        WETH_ADDR,
-                    ]),
-                    unwrapIntoRouter,
-                    v4EthForUsdc(ONE_ETH),
-                ],
-                lines: [["Amount", "600.0000 USDT"]],
-            },
-            {
-                kind: "a WRAP_ETH of 1 ETH into the router, an UNWRAP_WETH into the router, then a V4 swap of 1 ETH that the user settles",
-                commands: [0x0b, 0x0c, 0x10],
-                inputs: [
-                    encodeWrapEth(ROUTER_ADDR, ONE_ETH),
-                    unwrapIntoRouter,
-                    v4EthForUsdc(ONE_ETH),
-                ],
-                lines: [["Amount", "1.0000 ETH"]],
-            },
-            {
-                kind: "a WRAP_ETH of 1 ETH into the router, an UNWRAP_WETH into the router, then a V4 swap of 1.5 ETH that the user settles",
-                commands: [0x0b, 0x0c, 0x10],
-                inputs: [
-                    encodeWrapEth(ROUTER_ADDR, ONE_ETH),
-                    unwrapIntoRouter,
-                    v4EthForUsdc((ONE_ETH * 3n) / 2n),
-                ],
-                lines: [["Amount", "1.5000 ETH"]],
-            },
-        ])("$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) =>
@@ -2978,8 +2871,9 @@ describe("uniswap decoder", () => {
                         ...USDT_400_GROUP,
                         ...ONE_USDT_LINES(OTHER_ADDR),
                     ],
-                    // The last swap step's minimum.
+                    // Both swap steps pay USDC to the user, so the minimum
-                    minimum: "390.0000 USDC",
+                    // 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",
@@ -3417,6 +3311,683 @@ describe("uniswap decoder", () => {
 
             expect(detail(result, "Amount").value).toBe("Up to 1000.0000 USDT");
         });
+
+        // https://git.eeqj.de/sneak/AutistMask/issues/660 — Permit2 has no
+        // allowance of ETH, so a permit on the zero address reads as one on a
+        // token nothing knows. On next at 53551c6 such a permit's Allowance
+        // token line read ETH. A permit of 1 wei of the zero address before a
+        // V4 step of 5 ETH made the Amount line read 0.000000000000000001 ETH.
+        // With that permit to another spender and a SETTLE the router pays, no
+        // line gave the 5 ETH.
+        describe("a permit on the zero address", () => {
+            const FIVE_ETH = 5000000000000000000n;
+            // The lines of a permit of `amount` base units of the zero
+            // address for `spender`.
+            const zeroAddressLines = (amount, spender) => [
+                [
+                    "Permit2 allowance",
+                    amount + " base units (decimals unknown)",
+                ],
+                ["Allowance token", ZERO_ADDR],
+                ["Allowance spender", getAddress(spender)],
+            ];
+            // A V4 swap of 5 ETH for USDC. The user pays its SETTLE when
+            // `payerIsUser` is true; otherwise the router pays it from the
+            // transaction's value.
+            const v4FiveEth = (payerIsUser) =>
+                encodeV4Swap(
+                    new Uint8Array([
+                        V4_SWAP_EXACT_IN_SINGLE_ID,
+                        V4_SETTLE_ID,
+                        V4_TAKE_ALL_ID,
+                    ]),
+                    [
+                        encodeV4ExactInSingle(
+                            ZERO_ADDR,
+                            USDC_ADDR,
+                            FIVE_ETH,
+                            1n,
+                        ),
+                        settle(ZERO_ADDR, FIVE_ETH, payerIsUser),
+                        encodeV4TakeAll(USDC_ADDR, 1n),
+                    ],
+                );
+
+            test("a PERMIT2_PERMIT on the zero address names the address", () => {
+                const result = decodeSteps(
+                    [0x00, 0x0a],
+                    [
+                        V3_600,
+                        encodePermit2(
+                            ZERO_ADDR,
+                            1000000000000000000n,
+                            ROUTER_ADDR,
+                        ),
+                    ],
+                );
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "600.0000 USDT"],
+                    ...zeroAddressLines("1000000000000000000", ROUTER_ADDR),
+                ]);
+                expect(detail(result, "Allowance token").address).toBe(
+                    ZERO_ADDR,
+                );
+            });
+
+            test("a PERMIT2_PERMIT_BATCH entry on the zero address names the address", () => {
+                const result = decodeSteps(
+                    [0x03, 0x00],
+                    [
+                        encodePermit2Batch(
+                            [
+                                [USDT_ADDR, USDT_600],
+                                [ZERO_ADDR, 1000000000000000000n],
+                            ],
+                            ROUTER_ADDR,
+                        ),
+                        V3_600,
+                    ],
+                );
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "600.0000 USDT"],
+                    ...USDT_600_LINES,
+                    ...zeroAddressLines("1000000000000000000", ROUTER_ADDR),
+                ]);
+            });
+
+            test("a PERMIT2_PERMIT of 1 wei of the zero address, then a V4 step of 5 ETH the user settles, shows the 5 ETH", () => {
+                const result = decodeSteps(
+                    [0x0a, 0x10],
+                    [
+                        encodePermit2(ZERO_ADDR, 1n, ROUTER_ADDR),
+                        v4FiveEth(true),
+                    ],
+                );
+                expect(detail(result, "Token In").value).toBe("ETH (native)");
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "5.0000 ETH"],
+                    ...zeroAddressLines("1", ROUTER_ADDR),
+                ]);
+            });
+
+            test("a PERMIT2_PERMIT of 1 wei of the zero address to another spender, then a V4 step of 5 ETH the router settles, shows the 5 ETH", () => {
+                const result = decodeSteps(
+                    [0x0a, 0x10],
+                    [
+                        encodePermit2(ZERO_ADDR, 1n, OTHER_ADDR),
+                        v4FiveEth(false),
+                    ],
+                );
+                expect(detail(result, "Token In").value).toBe("ETH (native)");
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "5.0000 ETH"],
+                    ...zeroAddressLines("1", OTHER_ADDR),
+                ]);
+            });
+
+            test("a PERMIT2_PERMIT_BATCH entry of 1 wei of the zero address to another spender, then a V4 step of 5 ETH the router settles, shows the 5 ETH", () => {
+                const result = decodeSteps(
+                    [0x03, 0x10],
+                    [
+                        encodePermit2Batch([[ZERO_ADDR, 1n]], OTHER_ADDR),
+                        v4FiveEth(false),
+                    ],
+                );
+                expect(detail(result, "Token In").value).toBe("ETH (native)");
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "5.0000 ETH"],
+                    ...zeroAddressLines("1", OTHER_ADDR),
+                ]);
+            });
+        });
+
+        // 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
+        // SETTLE of 1 ETH that names the router as payer gave no ETH line.
+        describe("a V4 SETTLE of ETH that names the router as payer", () => {
+            const ONE_ETH = 1000000000000000000n;
+            // A V4 swap of `amount` of ETH for USDC. The SETTLE names the
+            // router as payer.
+            const v4EthFromRouter = (amount) =>
+                encodeV4Swap(
+                    new Uint8Array([
+                        V4_SWAP_EXACT_IN_SINGLE_ID,
+                        V4_SETTLE_ID,
+                        V4_TAKE_ALL_ID,
+                    ]),
+                    [
+                        encodeV4ExactInSingle(ZERO_ADDR, USDC_ADDR, amount, 1n),
+                        settle(ZERO_ADDR, amount, false),
+                        encodeV4TakeAll(USDC_ADDR, 1n),
+                    ],
+                );
+
+            test("after a V3 exact-in of 600 USDT, shows the 1 ETH moved from the sender", () => {
+                const result = decodeSteps(
+                    [0x00, 0x10],
+                    [V3_600, v4EthFromRouter(ONE_ETH)],
+                );
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "600.0000 USDT"],
+                    ["Moved from the sender", "1.0000 ETH"],
+                    ["Token moved", "ETH"],
+                    ["Moved to", "The swap step that spends it"],
+                ]);
+            });
+
+            // The UNWRAP_WETH leaves ETH in the router. The SETTLE may spend
+            // that ETH before the transaction's value.
+            test("after an UNWRAP_WETH into the router, shows at most 1 ETH moved from the sender", () => {
+                const result = decodeSteps(
+                    [0x00, 0x0c, 0x10],
+                    [
+                        encodeV3SwapExactIn(ROUTER_ADDR, USDT_600, 1n, [
+                            USDT_ADDR,
+                            WETH_ADDR,
+                        ]),
+                        encodeWrapEth(ROUTER_ADDR, 0n), // UNWRAP_WETH, same encoding
+                        v4EthFromRouter(ONE_ETH),
+                    ],
+                );
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "600.0000 USDT"],
+                    ["Moved from the sender", "Up to 1.0000 ETH"],
+                    ["Token moved", "ETH"],
+                    ["Moved to", "The swap step that spends it"],
+                ]);
+            });
+
+            test("after a WRAP_ETH of 0.5 ETH, adds the SETTLE's 0.5 ETH to the Amount line", () => {
+                const result = decodeSteps(
+                    [0x0b, 0x10],
+                    [
+                        encodeWrapEth(ROUTER_ADDR, ONE_ETH / 2n),
+                        v4EthFromRouter(ONE_ETH / 2n),
+                    ],
+                );
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "1.0000 ETH"],
+                ]);
+            });
+
+            // The WRAP_ETH sets Token In to ETH, and the UNWRAP_WETH leaves
+            // ETH in the router. The SETTLE may spend that ETH before the
+            // transaction's value, so its 1 ETH never joins the Amount line.
+            test("after a WRAP_ETH and an UNWRAP_WETH into the router, keeps the Amount line and shows at most 1 ETH moved from the sender", () => {
+                const result = decodeSteps(
+                    [0x0b, 0x0c, 0x10],
+                    [
+                        encodeWrapEth(ROUTER_ADDR, ONE_ETH / 2n),
+                        encodeWrapEth(ROUTER_ADDR, 0n), // UNWRAP_WETH, same encoding
+                        v4EthFromRouter(ONE_ETH),
+                    ],
+                );
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "0.5000 ETH"],
+                    ["Moved from the sender", "Up to 1.0000 ETH"],
+                    ["Token moved", "ETH"],
+                    ["Moved to", "The swap step that spends it"],
+                ]);
+            });
+
+            // A SETTLE of CONTRACT_BALANCE pays all the router holds, an
+            // amount the calldata does not state.
+            test("of CONTRACT_BALANCE, on the step that sets the input side, shows an unknown amount moved from the sender", () => {
+                const result = decodeSteps(
+                    [0x10],
+                    [
+                        encodeV4Swap(
+                            new Uint8Array([
+                                V4_SWAP_EXACT_IN_SINGLE_ID,
+                                V4_SETTLE_ID,
+                                V4_TAKE_ALL_ID,
+                            ]),
+                            [
+                                encodeV4ExactInSingle(
+                                    ZERO_ADDR,
+                                    USDC_ADDR,
+                                    ONE_ETH,
+                                    1n,
+                                ),
+                                settle(ZERO_ADDR, 2n ** 255n, false), // CONTRACT_BALANCE
+                                encodeV4TakeAll(USDC_ADDR, 1n),
+                            ],
+                        ),
+                    ],
+                );
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Moved from the sender", UNDECODED],
+                    ["Token moved", "ETH"],
+                    ["Moved to", "The swap step that spends it"],
+                ]);
+            });
+        });
+
+        // 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
@@ -4159,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
+    // A zero balance check sets neither Token Out nor the minimum. The route
-    // output side, and it guarantees nothing. No step pays anyone, so the
+    // pays only the WRAP_ETH's WETH, to the router, where it stays.
-    // minimum is not said to be received.
+    test("a zero balance check after a WRAP_ETH into the router names no output token and no minimum", () => {
-    test("a zero balance check with no earlier minimum states no minimum", () => {
         const data = buildExecute(
             solidityPacked(["uint8", "uint8"], [0x0b, 0x0e]),
             [
@@ -4175,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, "Token Out").value).toBe(
-        expect(detail(result, "Min. paid out").value).toBe(
+            "Unknown (not named in the calldata)",
-            "None (no minimum guaranteed)",
+        );
+        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(
@@ -1661,9 +1717,18 @@ describe("any token left in the router is not received", () => {
             ),
             min: "1990.0000 USDC",
         },
-        {
+    ])("$kind reads as a swap paid to the user", ({ data, min }) => {
-            kind: "a swap paying WETH to the router, an UNWRAP_WETH into the router, then a V4 swap settling all the ETH from the router",
+        const result = decode(data);
-            data: execute(
+        expect(labels(result)).toEqual(PAID_TO_USER);
+        expect(detail(result, "Min. received").value).toBe(min);
+    });
+
+    // https://git.eeqj.de/sneak/AutistMask/issues/682 — the SETTLE spends all
+    // the router's ETH, the transaction's value included, so the sender pays
+    // an amount the calldata does not state.
+    test("a swap paying WETH to the router, an UNWRAP_WETH into the router, then a V4 swap settling all the ETH from the router reads as a swap paid to the user", () => {
+        const result = decode(
+            execute(
                 swapToWeth(ADDRESS_THIS),
                 unwrapWeth(ADDRESS_THIS),
                 v4Swap(
@@ -1672,12 +1737,23 @@ describe("any token left in the router is not received", () => {
                     takeAll(USDC),
                 ),
             ),
-            min: "1990.0000 USDC",
+        );
-        },
+        expect(labels(result)).toEqual([
-    ])("$kind reads as a swap paid to the user", ({ data, min }) => {
+            "Protocol",
-        const result = decode(data);
+            "Token In",
-        expect(labels(result)).toEqual(PAID_TO_USER);
+            "Amount",
-        expect(detail(result, "Min. received").value).toBe(min);
+            "Moved from the sender",
+            "Token moved",
+            "Moved to",
+            "Token Out",
+            "Min. received",
+            "Steps",
+            "Deadline",
+        ]);
+        expect(detail(result, "Moved from the sender").value).toBe(
+            "Unknown (could not be decoded)",
+        );
+        expect(detail(result, "Min. received").value).toBe("1990.0000 USDC");
     });
 });
 
@@ -2800,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, "Token Out").value).toBe(UNNAMED);
-        expect(detail(withFlag, "Min. paid out").value).toBe(
+        expect(detail(withFlag, "Min. paid out")).toBeUndefined();
-            "None (no minimum guaranteed)",
+        expect(detail(withFlag, "Min. received")).toBeUndefined();
-        );
     });
 
     // Only the routers from UniversalRouterV2 on let a PERMIT2_PERMIT fail.

tests/unknownScaleDisplay.test.js

@@ -103,7 +103,7 @@ describe("balanceLine", () => {
     });
 
     test("an unknown quantity produces no fiat figure, a zero one does", () => {
-        prices.NOVEL = 3;
+        prices[NOVEL] = 3;
         const unknown = balanceLine("NOVEL", null, 3, NOVEL);
         const zero = balanceLine("NOVEL", 0, 3, NOVEL);
         // A price times an unknown quantity is not $0.00: that is the same
@@ -162,7 +162,7 @@ describe("getAddressValue", () => {
     // make it incomplete.
     test("an unknown balance makes the total partial, a zero balance does not", () => {
         prices.ETH = 2000;
-        prices.NOVEL = 3;
+        prices[NOVEL] = 3;
         const unknown = getAddressValue(address(null));
         const zero = getAddressValue(address("0.0"));
         expect(unknown).not.toEqual(zero);
@@ -172,7 +172,7 @@ describe("getAddressValue", () => {
 
     test("an unknown balance is not priced as zero of the token", () => {
         prices.ETH = 2000;
-        prices.NOVEL = 3;
+        prices[NOVEL] = 3;
         // The same row with a real quantity of 10 is worth $30. Neither that
         // figure nor a confident $0.00 may be stated for the unknown one.
         expect(getAddressValue(address("10.0"))).toEqual({