fix: a swap split across steps the user pays for shows every amount it spends (closes #625)

The Amount line gave only the first swap step's amount. It now gives the
total the steps take of Token In: the amount of the step that sets the
input side plus each later take of it by a step the user pays. A V4
step, the first included, takes what its SETTLEs paid by the user state.
A take of another token, one after an amount that is not a quantity, or
one of unknown amount gets lines of its own. A step that may take what
the decoder did not read gets one line saying so and leaves no figure.
A PERMIT2_PERMIT names Token In; its amount stands only in the plain
shape of Uniswap's own routes.

Also closes #628.

Model: opus-5-5

README.md

@@ -1116,22 +1116,23 @@ with the same floor (`.5` reads `.5000`).
 
 **Specific Exception — unknown token scale:** Calldata carries base units and no
 scale, so every amount on the dApp approval screen needs the token's `decimals`.
-It is resolved from the bundled token list, then from the tokens the user
-tracks, then from what the block explorer reported for the contract
-(`resolveTokenDecimals()` in `src/shared/approvalAmount.js`). Where none of them
-answers, the amount is not formatted: the line reads
-`5000000000 base units (decimals unknown)`. A guessed scale is not an
-approximation but a different number — 1,000 units of a 6-decimal token
-formatted at 18 decimals reads `0.000000001` — on the screen whose only job is
-to state what is being authorized. Both amount paths of that screen take this
-rule: the ERC-20 `transfer`/`approve` line (`src/popup/views/approval.js`) and
-the swap's `Amount` and `Min. received` lines (`src/shared/uniswap.js`). The
-token permission warning on the signature screen takes the same rule for its
-amounts. An unbounded allowance or permit needs no scale to describe and is
-still shown as `Unlimited`. A source's answer counts only if it is a whole
-number from 0 to 80: `decimals()` returns a `uint8`, but `formatUnits()` cannot
-format more than 80 decimal places, so a token that reports 81 to 255 is shown
-as one whose scale nothing knows.
+It is resolved from the bundled token list, then from the tokens the user tracks
+on the network the transaction is for, then, when that is the active network,
+from what the block explorer reported for the contract in the wallet's balances,
+which are the active network's only (`resolveTokenDecimals()` in
+`src/shared/approvalAmount.js`). Where none of them answers, the amount is not
+formatted: the line reads `5000000000 base units (decimals unknown)`. A guessed
+scale is not an approximation but a different number — 1,000 units of a
+6-decimal token formatted at 18 decimals reads `0.000000001` — on the screen
+whose only job is to state what is being authorized. Both amount paths of that
+screen take this rule: the ERC-20 `transfer`/`approve` line
+(`src/popup/views/approval.js`) and the swap's `Amount` and `Min. received`
+lines (`src/shared/uniswap.js`). The token permission warning on the signature
+screen takes the same rule for its amounts. An unbounded allowance or permit
+needs no scale to describe and is still shown as `Unlimited`. A source's answer
+counts only if it is a whole number from 0 to 80: `decimals()` returns a
+`uint8`, but `formatUnits()` cannot format more than 80 decimal places, so a
+token that reports 81 to 255 is shown as one whose scale nothing knows.
 
 The rule holds only if nothing invents a scale UPSTREAM of it. Those three
 sources are read as authoritative, so a value written into one of them cannot be
@@ -1189,14 +1190,8 @@ number. They can read:
   `amountOut`, the exact amount it buys.
 - `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. The line shows the
-  amount of the step that sets the input side: the last `PERMIT2_PERMIT` step if
-  there is one, otherwise the first V2 or V3 exact-in, V2 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, as described below. A V2 exact-out step gives its `amountInMax`, and
-  a V4 swap step the `amountIn` of the swap action that spends its input
-  currency.
+  whole open delta", so the calldata states no quantity. Transaction Decoding
+  below gives the steps whose amounts the line shows.
 - `Whatever an earlier step sent to the pair (V2 already paid)`: the swap's
   `Amount` line, when the amount it shows is a V2 exact-in `amountIn` of zero.
   The router reads that zero as "the pair already holds the input tokens": the
@@ -1240,7 +1235,9 @@ only when no earlier step set it. It finds each side by three rules:
    is their sum; in any other case the step gives no `Amount`. The decoder reads
    no amount from an exact-out action, and an open delta is not a stated amount.
    Its `Min. received` is found the same way, from the `amountOutMin` of the
-   actions that buy the output currency.
+   actions that buy the output currency. When the user pays the step any of the
+   input currency, its `Amount` is what the user pays instead (see Transaction
+   Decoding).
 3. If any swap action in the step could not be read, only `SETTLE`,
    `SETTLE_ALL`, `TAKE` and `TAKE_ALL` name its sides, and the step gives no
    `Amount` or `Min. received`. A side they did not name is unknown, and the
@@ -1530,9 +1527,11 @@ first screen that cannot be rendered from saved state, such as Send or AddToken,
 or at AddressToken for any token but the native one, because that token was
 picked on the previous network. The cut stack is saved with the switch, so a
 popup closed straight after it and reopened onto Settings lands in the same
-place. "Back" then renders the screen it lands on for the new network, except
-ConfirmTx, which keeps the network its transaction was reviewed on, and anything
-typed there and not saved, which belonged to the previous network, is dropped.
+place. "Back" then renders the screen it lands on for the new network, and
+anything typed there and not saved, which belonged to the previous network, is
+dropped. ConfirmTx, WaitTx, SuccessTx, ErrorTx and TransactionDetail are
+rendered instead for the network of the transaction they show: the network it
+was reviewed on for ConfirmTx, and the network it was sent on for the others.
 Without a wallet the stack is not cut, because it starts at Welcome, which shows
 nothing from a network.
 
@@ -1891,14 +1890,17 @@ view would leave a wallet one click from deletion.
       no recipient." instead
     - Transaction hash: full hash (tap to copy) + etherscan link
     - Count-up timer: "Waiting for confirmation... Ns"
-- **Behavior**: Polls `getTransactionReceipt` every 10 seconds. The wait is
-  persisted: closing and reopening the popup resumes the poll, with the elapsed
-  counter and the timeout deadline still measured from the original broadcast. A
-  lookup that fails is retried on the next tick rather than counted as a missing
-  receipt, because a failed lookup says nothing about the transaction; but six
-  failures in a row (60 seconds at the poll cadence) end the wait, so an RPC
-  that never answers cannot leave it running indefinitely. Any lookup that
-  answers resets that count.
+- **Behavior**: Polls `getTransactionReceipt` every 10 seconds. The screen
+  describes the transaction on the network it was sent on, whichever network is
+  active: the receipt is asked of that network's RPC endpoint, the one Settings
+  has for it, and the To and hash links open that network's explorer. The wait
+  is persisted: closing and reopening the popup resumes the poll, with the
+  elapsed counter and the timeout deadline still measured from the original
+  broadcast. A lookup that fails is retried on the next tick rather than counted
+  as a missing receipt, because a failed lookup says nothing about the
+  transaction; but six failures in a row (60 seconds at the poll cadence) end
+  the wait, so an RPC that never answers cannot leave it running indefinitely.
+  Any lookup that answers resets that count.
 - **Transitions**:
     - Receipt found → **SuccessTx**
     - A lookup that answers "no receipt" 60 seconds or more after broadcast →
@@ -1919,9 +1921,12 @@ view would leave a wallet one click from deletion.
     - Amount + symbol
     - To: color dot + full address + etherscan link, or for a contract creation
       the same sentence as on WaitTx
-    - Block number
+    - Block number + etherscan link
     - Transaction hash: full hash (tap to copy) + etherscan link
     - "Done" button
+- **Behavior**: As on WaitTx, every etherscan link on the screen opens the
+  explorer of the network the transaction was sent on, whichever network is
+  active.
 - **Transitions**:
     - "Done" in the approval popup → closes the popup window
     - "Done" otherwise → resets the navigation stack, then → **AddressToken**
@@ -1941,6 +1946,9 @@ view would leave a wallet one click from deletion.
     - Transaction hash section (hidden if broadcast failed before getting hash):
       full hash (tap to copy) + etherscan link
     - "Done" button
+- **Behavior**: As on WaitTx, every etherscan link on the screen opens the
+  explorer of the network the transaction was sent on, whichever network is
+  active.
 - **Transitions**:
     - "Done" in the approval popup → closes the popup window
     - "Done" otherwise → resets the navigation stack, then → **AddressToken**
@@ -1963,7 +1971,10 @@ view would leave a wallet one click from deletion.
 #### TransactionDetail (`transaction`)
 
 - **When**: User tapped a transaction row on Home, AddressDetail, or
-  AddressToken.
+  AddressToken. The screen describes the transaction on the network it was sent
+  on, whichever network is active: its block, network details, decoded details
+  and raw data are read from that network's Blockscout, the one Settings has for
+  it, and its etherscan links open that network's explorer.
 - **Elements** (grouped into logical blocks using light well containers; field
   labels are self-explanatory so groups have no headings):
     - "Transaction" heading, "Back" button
@@ -2364,10 +2375,11 @@ view would leave a wallet one click from deletion.
     - Site origin (bold, scheme and port included) + "wants to send a
       transaction"
     - Decoded action (if calldata is recognized): action name, token details,
-      amounts, what each `PERMIT2_TRANSFER_FROM` moves and where to, steps,
-      deadline, and unless a swap pays only the From address, a `Paid to` line
-      for each other address it pays, or saying that a token stays in the router
-      or who it pays is unknown (see Transaction Decoding)
+      amounts, what each swap step spends that the `Amount` line does not give,
+      what each `PERMIT2_TRANSFER_FROM` moves and where to, steps, deadline, and
+      unless a swap pays only the From address, a `Paid to` line for each other
+      address it pays, or saying that a token stays in the router or who it pays
+      is unknown (see Transaction Decoding)
     - From: color dot + full address + etherscan link
     - Contract: color dot + full address + etherscan link, token symbol label if
       known; for a contract creation, the same sentence as on WaitTx
@@ -2380,6 +2392,8 @@ view would leave a wallet one click from deletion.
     - Raw data: full calldata displayed inline (shown if present)
     - Password input and an error line
     - "Confirm" / "Reject" buttons
+- **Behavior**: Every etherscan link on the screen opens the explorer of the
+  network the transaction was populated on, whichever network is active.
 - **Transitions**:
     - "Confirm" (correct password) → decrypts and signs the transaction it was
       shown, exactly as shown, hands the signed transaction to the background to
@@ -2988,8 +3002,8 @@ Currently supported:
   "Swap USDT → ETH"), token addresses, amounts, execution steps, and deadline.
   The swap summary is shown only for a transaction sent to one of the Universal
   Router addresses Uniswap publishes for the network: on TxApproval the network
-  the transaction is for, on TransactionDetail the active network. The same
-  calldata sent to any other address is shown as raw data. Decodes Permit2,
+  the transaction is for, on TransactionDetail the network it was sent on. The
+  same calldata sent to any other address is shown as raw data. Decodes Permit2,
   V2/V3/V4 swaps, wrap/unwrap, and balance checks. A V4 swap action is read only
   in the parameter shape deployed on mainnet and Sepolia, not in the newer one
   on `v4-periphery` `main`, which adds a `minHopPriceX36` field. An action in
@@ -3075,37 +3089,40 @@ 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. The router pays a `SETTLE` of
-  `OPEN_DELTA` (zero) only what its step still owes of that token when the
-  `SETTLE` runs, so one from the router counts as spending the amounts the
-  step's swap actions state they spend of that token only when every action in
-  the step could be read, every swap action names the token it spends and the
-  token it buys (a swap action with an empty path swaps nothing), the `SETTLE`
-  is the step's only `SETTLE` or `SETTLE_ALL` of that token and comes after
-  every swap action, no swap action buys that token, and the swap actions that
-  spend it state a quantity together; otherwise it counts as spending nothing.
-  So the rest of a V4 `SETTLE` of more than its swap spends, taken to the
-  router, the WETH of a `WRAP_ETH`, and a token a swap pays the router on the
-  way to the output, each stays in the router when later steps do not spend all
-  of it, where anyone can take it in a later transaction. The router sends ETH
-  as written, so a `TRANSFER` of `CONTRACT_BALANCE` of ETH always reverts and
-  pays out nothing. A step paying a token to the V2 pair that the very next step
-  spends, as a V2 exact-in of that token whose `amountIn` is `ALREADY_PAID`
-  (zero) or `CONTRACT_BALANCE`, is a hop, not a payout: Uniswap's mixed routes
-  pay the next V2 pair directly, and the router enforces that swap's own
-  minimum. The decoder checks that the address paid is that pair, deriving it
-  from the V2 factory and pair init code hash the network's routers were
-  deployed with and the first two tokens of that step's path; a payment to any
-  other address is named. (Sepolia's `UniversalRouterV1_2_V2Support` was
-  deployed with placeholders for both values, so no V2 swap step can succeed on
-  that router.) Every other payment counts, in whichever step and of whatever
-  token, a share of the output included: an interface fee paid to another
-  address by `PAY_PORTION`, `TRANSFER` or `TAKE_PORTION` is named, and the
-  minimum reads `Min. paid out`, because the swap's minimum includes the fee.
-  The minimum reads `Min. received` only when some step pays the transaction's
-  sender (the From address on TxApproval, the sender the explorer reports on
-  TransactionDetail) and no `Paid to` line is shown. `Paid to` lines after
-  `Token Out` name each other address paid; one reads
+  WETH from it reads as leaving the WETH there. A `SETTLE` of `OPEN_DELTA`
+  (zero), and a `SETTLE_ALL`, pay only what the step still owes of their token
+  when they run. The decoder takes that to be the amounts the step's swap
+  actions state they spend of that token only when every action in the step
+  could be read, every swap action names the token it spends and the token it
+  buys (a swap action with an empty path swaps nothing), the `SETTLE` or
+  `SETTLE_ALL` is the step's only `SETTLE` or `SETTLE_ALL` of that token and
+  comes after every swap action, no swap action buys that token, no `TAKE`,
+  `TAKE_ALL` or `TAKE_PORTION` in the step takes it (a `TAKE` of a stated amount
+  adds to what the step owes), and the swap actions that spend it state a
+  quantity together; otherwise it does not know the amount, and such a `SETTLE`
+  from the router counts as spending nothing. So the rest of a V4 `SETTLE` of
+  more than its swap spends, taken to the router, the WETH of a `WRAP_ETH`, and
+  a token a swap pays the router on the way to the output, each stays in the
+  router when later steps do not spend all of it, where anyone can take it in a
+  later transaction. The router sends ETH as written, so a `TRANSFER` of
+  `CONTRACT_BALANCE` of ETH always reverts and pays out nothing. A step paying a
+  token to the V2 pair that the very next step spends, as a V2 exact-in of that
+  token whose `amountIn` is `ALREADY_PAID` (zero) or `CONTRACT_BALANCE`, is a
+  hop, not a payout: Uniswap's mixed routes pay the next V2 pair directly, and
+  the router enforces that swap's own minimum. The decoder checks that the
+  address paid is that pair, deriving it from the V2 factory and pair init code
+  hash the network's routers were deployed with and the first two tokens of that
+  step's path; a payment to any other address is named. (Sepolia's
+  `UniversalRouterV1_2_V2Support` was deployed with placeholders for both
+  values, so no V2 swap step can succeed on that router.) Every other payment
+  counts, in whichever step and of whatever token, a share of the output
+  included: an interface fee paid to another address by `PAY_PORTION`,
+  `TRANSFER` or `TAKE_PORTION` is named, and the minimum reads `Min. paid out`,
+  because the swap's minimum includes the fee. The minimum reads `Min. received`
+  only when some step pays the transaction's sender (the From address on
+  TxApproval, the sender the explorer reports on TransactionDetail) and no
+  `Paid to` line is shown. `Paid to` lines after `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)`
@@ -3117,8 +3134,71 @@ 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`. After the `Amount` line (after `Token In` when
-  there is none), each `PERMIT2_TRANSFER_FROM` but one into the router, in step
+  minimum reads `Min. paid out`. The `Amount` line gives the total the steps
+  take of `Token In`, from the step that sets the input side on: the first V2 or
+  V3 exact-in, V2 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 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 V2
+  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`. A
+  later step paid from the router spends what the router holds and takes
+  nothing, and so does a V2 exact-in whose `amountIn` is `ALREADY_PAID`. A later
+  take of `Token In` is added to the total while both are quantities: a V3
+  exact-in of 600 USDT and a V2 exact-in of 400 USDT, both paid by the user,
+  read `1000.0000 USDT`. When the decoder does not know a take's amount, the
+  total is not known and there is no `Amount` line. `Token In` is the token of
+  the last `PERMIT2_PERMIT` the decoder reads, when there is one. Its amount,
+  `Unlimited` included, stands as the `Amount` figure in place of the total only
+  in the plain shape of Uniswap's own routes: it is the only `PERMIT2_PERMIT`,
+  its spender is the router, the router may not let it fail, no step before it
+  takes its token or a token the decoder does not know, and the decoder reads
+  every step after it in full. Permit2 then lets the router take no more of the
+  token than that amount, so the permit covers every take of it. A step the
+  decoder does not read in full may raise what Permit2 lets the router take, as
+  a `PERMIT2_PERMIT_BATCH` can: a command the decoder does not read (listed at
+  the end of this section), a step whose input it cannot read, in whole or in
+  part, and a step it fails on. In any other case the line gives the total, as
+  with no permit. When the step that sets the input side spends a token other
+  than the permit's, or one the decoder does not know, its amount gets lines of
+  its own and the total has no figure to start from: unless the permit's amount
+  stands there is no `Amount` line, and each take of the permit's token gets
+  lines of its own. Each take the total does not count gives three lines after
+  the `Amount` line (after `Token In` when there is none): one of a token other
+  than `Token In`; one of `Token In` after an amount that is not a quantity (a
+  V4 open delta, `ALREADY_PAID`, which keep their wording on the `Amount` line,
+  or no stated amount, as of a V4 exact-out step); and one whose amount the
+  decoder does not know. When the step that sets the input side states no amount
+  and there is no `Amount` line, that step gets them too whenever another take's
+  lines give a figure, so that figure cannot read as all that leaves. They come
+  in step order, the step that sets the input side first when it has them:
+  `Moved from the sender`, its amount, worded as the `Amount` line words one, or
+  `Unknown (could not be decoded)` when the decoder does not know it;
+  `Token moved`, giving the token's address as the `Token In` line does; and
+  `Moved to`, which reads `The swap step that spends it`. A token the decoder
+  does not know gives the `Moved from the sender` line alone. A step may also
+  take from the user's wallet what the decoder did not read: a V4 step whose
+  input or one of whose `SETTLE`s or `SETTLE_ALL`s it cannot read, which the
+  router still runs; a V2 or V3 exact-in or V2 exact-out step or a
+  `PERMIT2_TRANSFER_FROM` whose input it cannot read; every
+  `PERMIT2_TRANSFER_FROM_BATCH`; every `V3_SWAP_EXACT_OUT`, which the decoder
+  does not read, wherever it stands; every `EXECUTE_SUB_PLAN`, wherever it
+  stands; and every step it fails on. Each such step gives one
+  `Moved from the sender` line among those, reading
+  `Unknown (could not be decoded)`. That line, or any line for a token the
+  decoder does not know, leaves no `Amount` line, whose figure might be too low,
+  and such a step before a `PERMIT2_PERMIT` keeps the permit's amount from
+  standing. Then each `PERMIT2_TRANSFER_FROM` but one into the router, in step
   order, gives three lines: `Moved from the sender`, the amount it moves, for
   example `1000000.0000 USDT`; `Token moved`, giving the token's address as the
   `Token In` line does; and `Moved to`, which reads

src/popup/viewRouter.js

@@ -145,12 +145,15 @@ function isRenderablePendingTx(value) {
 
 // The stored transaction transactionDetail.render() shows. contractAddress is
 // optional on an ETH transfer, and reaches addressDotHtml() when it is there.
+// `chainId` picks the network whose explorer the links open and whose
+// Blockscout the transaction is read from, so it has to name one.
 function isRenderableTx(value) {
     return (
         isRecord(value) &&
         isAddressText(value.from) &&
         isAddressText(value.to) &&
-        (!value.contractAddress || isAddressText(value.contractAddress))
+        (!value.contractAddress || isAddressText(value.contractAddress)) &&
+        SUPPORTED_CHAIN_IDS.has(value.chainId)
     );
 }
 
@@ -202,11 +205,19 @@ function renderView(view, state, views) {
             if (!data.hash) return false;
             if (!isAddressText(data.to)) return false;
             if (!isRenderableDecoded(data.decoded)) return false;
+            // `chainId` picks the network whose explorer the links open, so
+            // when it is there it has to name one. Likewise on error-tx.
+            if (data.chainId && !SUPPORTED_CHAIN_IDS.has(data.chainId)) {
+                return false;
+            }
             views.txStatus.renderSuccess();
             return true;
         case "error-tx":
             if (!data.message) return false;
             if (!isAddressText(data.to)) return false;
+            if (data.chainId && !SUPPORTED_CHAIN_IDS.has(data.chainId)) {
+                return false;
+            }
             views.txStatus.renderError();
             return true;
         default:

src/popup/views/approval.js

@@ -11,6 +11,7 @@ const {
     onViewLeave,
     formatFee,
     tokenLabel,
+    tokenSourcesByChainId,
 } = require("./helpers");
 const { state, saveState, currentNetwork } = require("../../shared/state");
 const {
@@ -57,9 +58,15 @@ const { notify, runtimeApi, sendMessage } = require("../../shared/browserApi");
 
 const erc20Iface = new Interface(ERC20_ABI);
 
-function approvalAddressHtml(address) {
+// The link opens the explorer of the network with `chainId`, or of the active
+// network when none is given. A chain id that names no network has no
+// explorer, so the address is drawn without a link.
+function approvalAddressHtml(address, chainId) {
     const title = addressTitle(address, state.wallets);
-    return renderAddressHtml(address, { title });
+    if (chainId && !networkByChainId(chainId)) {
+        return renderAddressHtml(address, { title, noLink: true });
+    }
+    return renderAddressHtml(address, { title, chainId });
 }
 
 // The amount line for a decoded ERC-20 call. With a known scale it is the
@@ -85,13 +92,12 @@ function tokenAmountText(rawAmount, decimals, symbol) {
 function decodeCalldata(data, toAddress, chainId, fromAddress) {
     if (!data || data === "0x" || data.length < 10) return null;
 
-    // Where a token's scale is looked for, for every decoder below: the ERC-20
-    // amount line and the swap's Amount and Min. received lines resolve it the
-    // same way, and refuse to format the same way when it is nowhere.
-    const decimalsSources = {
-        trackedTokens: state.trackedTokens,
-        wallets: state.wallets,
-    };
+    // Where a token's name and scale are looked for, for every decoder below:
+    // what the wallet knows of the tokens on the network with `chainId`, which
+    // need not be the active one. The ERC-20 amount line and the swap's Amount
+    // and Min. received lines resolve the scale the same way, and refuse to
+    // format the same way when it is nowhere.
+    const decimalsSources = tokenSourcesByChainId(chainId);
 
     // Try ERC-20 (approve / transfer)
     try {
@@ -261,10 +267,7 @@ function showTxApproval(details) {
 
     const toAddr = approvedTx.to;
     const ethValue = formatEther(approvedTx.value || "0");
-    const sources = {
-        trackedTokens: state.trackedTokens,
-        wallets: state.wallets,
-    };
+    const sources = tokenSourcesByChainId(approvedTx.chainId);
 
     // Build txInfo for status screens
     pendingTxDetails = {
@@ -341,17 +344,24 @@ function showTxApproval(details) {
         };
     }
 
+    // Every address link on this screen opens the explorer of the network the
+    // transaction is for, which the Network line names, whichever network is
+    // active.
     $("approve-tx-origin").textContent = details.origin;
-    $("approve-tx-from").innerHTML = approvalAddressHtml(details.approvedFrom);
+    $("approve-tx-from").innerHTML = approvalAddressHtml(
+        details.approvedFrom,
+        approvedTx.chainId,
+    );
 
-    // Show token symbol next to contract address if known
-    const symbol = toAddr ? tokenLabel(toAddr) : null;
+    // Show token symbol next to contract address if known on the network the
+    // transaction is for
+    const symbol = toAddr ? tokenLabel(toAddr, approvedTx.chainId) : null;
     if (toAddr) {
         let toHtml = "";
         if (symbol) {
             toHtml += `<div class="font-bold mb-1">${escapeHtml(symbol)}</div>`;
         }
-        toHtml += approvalAddressHtml(toAddr);
+        toHtml += approvalAddressHtml(toAddr, approvedTx.chainId);
         $("approve-tx-to").innerHTML = toHtml;
     } else {
         $("approve-tx-to").innerHTML = escapeHtml(CONTRACT_CREATION_TEXT);
@@ -388,9 +398,12 @@ function showTxApproval(details) {
             detailsHtml += `<div class="text-muted">${escapeHtml(d.label)}</div>`;
             if (d.address) {
                 if (d.isToken) {
-                    detailsHtml += `<div class="font-bold">${escapeHtml(tokenLabel(d.address) || "Unknown token")}</div>`;
+                    detailsHtml += `<div class="font-bold">${escapeHtml(tokenLabel(d.address, approvedTx.chainId) || "Unknown token")}</div>`;
                 }
-                detailsHtml += approvalAddressHtml(d.address);
+                detailsHtml += approvalAddressHtml(
+                    d.address,
+                    approvedTx.chainId,
+                );
             } else {
                 detailsHtml += `<div class="font-bold">${escapeHtml(d.value)}</div>`;
             }

src/popup/views/confirmTx.js

@@ -23,12 +23,10 @@ const {
     goBack,
     onViewLeave,
     formatFee,
+    reviewedNetworkProvider,
 } = require("./helpers");
 const { state, currentNetwork } = require("../../shared/state");
-const {
-    networkByChainId,
-    nativeCurrencyByChainId,
-} = require("../../shared/networks");
+const { nativeCurrencyByChainId } = require("../../shared/networks");
 const { getSignerForAddress } = require("../../shared/wallet");
 const { walletDefect } = require("../../shared/walletDefects");
 const { decryptWithPassword } = require("../../shared/vault");
@@ -458,20 +456,6 @@ function setVisible(id, visible) {
     $(id).style.visibility = visible ? "visible" : "hidden";
 }
 
-// The node of the network this transaction was reviewed for, which need not be
-// the active one: the popup can reopen onto this screen after Settings switched
-// the network. Its RPC URL is the one Settings has for that network: the
-// active network's is state.rpcUrl, any other's the one remembered for it (see
-// applyChainSwitchFields()).
-function reviewedNetworkProvider(txInfo) {
-    const net = networkByChainId(txInfo.chainId);
-    if (net.id === state.networkId) {
-        return getProvider(state.rpcUrl, net.id);
-    }
-    const remembered = state.networkEndpoints[net.id] || {};
-    return getProvider(remembered.rpcUrl || net.defaultRpcUrl, net.id);
-}
-
 async function estimateGas(txInfo) {
     try {
         const provider = reviewedNetworkProvider(txInfo);

src/popup/views/helpers.js

@@ -1,4 +1,7 @@
-// Shared DOM helpers used by all views.
+// Helpers the views in this directory share: showing a view and going back,
+// error and flash lines and the warning banners, formatting of amounts, fees,
+// balances, addresses and dates, the RPC and Blockscout URLs, node and tokens
+// of the network a chain id names, explorer links, and click-to-copy.
 //
 // Escaping rule for every view in this directory, since they all build
 // markup by concatenation: any VALUE interpolated into an innerHTML string
@@ -19,6 +22,7 @@ const {
     isBelowOneMillionth,
 } = require("../../shared/amountDisplay");
 const { resolveTokenSymbol } = require("../../shared/approvalAmount");
+const { getProvider } = require("../../shared/balances");
 const { DEBUG } = require("../../shared/constants");
 const { escapeHtml } = require("../../shared/html");
 const { isDebug } = require("../../shared/log");
@@ -296,15 +300,30 @@ function nativeCurrency() {
     return currentNetwork().nativeCurrency;
 }
 
-// The symbol shown for a token line, resolved from the bundled list, the
-// tokens the user tracks, and the explorer's report — the same chain the
-// amount line's scale comes from. Null when no source names one, so the token
-// lines keep saying `Unknown token` for a token nothing knows.
-function tokenLabel(address) {
-    return resolveTokenSymbol(address, {
-        trackedTokens: state.trackedTokens,
-        wallets: state.wallets,
-    });
+// What the wallet knows of the tokens on the network with this chain id, or
+// on the active network when no chain id is given, as the `sources` that
+// resolveTokenSymbol() and resolveTokenDecimals() take. A contract address
+// names a token on one network only, and every token balance held is the
+// active network's, so another network gets the tokens tracked on it
+// (state.networkTrackedTokens, see applyChainSwitchFields()) and no balances.
+function tokenSourcesByChainId(chainId) {
+    const net = chainId ? networkByChainId(chainId) : currentNetwork();
+    if (net && net.id === state.networkId) {
+        return { trackedTokens: state.trackedTokens, wallets: state.wallets };
+    }
+    return {
+        trackedTokens: (net && state.networkTrackedTokens[net.id]) || [],
+        wallets: [],
+    };
+}
+
+// The symbol shown for a token line on the network with `chainId`, or on the
+// active network when none is given: from the bundled list, the tokens the
+// user tracks, and the explorer's report, the sources the amount line's scale
+// comes from. Null when no source names one, so the token lines keep saying
+// `Unknown token` for a token nothing knows.
+function tokenLabel(address, chainId) {
+    return resolveTokenSymbol(address, tokenSourcesByChainId(chainId));
 }
 
 // A network fee in wei as the confirmation and approval screens both show it:
@@ -607,6 +626,30 @@ const EXT_ICON =
     `<path d="M7 1.5h3.5V5M7 5.5L10.5 1.5"/>` +
     `</svg></span>`;
 
+// The RPC and Blockscout URLs Settings has for the network with this chain id,
+// which need not be the active one: ConfirmTx, WaitTx and TransactionDetail
+// use the network their transaction's chain id names, and the popup can reopen
+// onto them after Settings switched the network. The active network's are
+// state.rpcUrl and state.blockscoutUrl, any other's the ones remembered for it,
+// or its defaults (see applyChainSwitchFields()).
+function endpointsByChainId(chainId) {
+    const net = networkByChainId(chainId);
+    if (net.id === state.networkId) {
+        return { rpcUrl: state.rpcUrl, blockscoutUrl: state.blockscoutUrl };
+    }
+    const remembered = state.networkEndpoints[net.id] || {};
+    return {
+        rpcUrl: remembered.rpcUrl || net.defaultRpcUrl,
+        blockscoutUrl: remembered.blockscoutUrl || net.defaultBlockscoutUrl,
+    };
+}
+
+// The node of the network a transaction was reviewed for.
+function reviewedNetworkProvider(txInfo) {
+    const net = networkByChainId(txInfo.chainId);
+    return getProvider(endpointsByChainId(txInfo.chainId).rpcUrl, net.id);
+}
+
 // Block-explorer URLs. The origin is a per-network constant from
 // src/shared/networks.js, the explorer of the network with `chainId`, or of
 // the active network when no chain id is given; only the path segment is
@@ -747,6 +790,7 @@ module.exports = {
     keyMaterialName,
     unknownableAmount,
     nativeCurrency,
+    tokenSourcesByChainId,
     tokenLabel,
     formatFee,
     addressDotHtml,
@@ -762,6 +806,8 @@ module.exports = {
     attachCopyHandlers,
     etherscanLinkHtml,
     explorerUrl,
+    endpointsByChainId,
+    reviewedNetworkProvider,
     EXT_ICON,
     truncateMiddle,
     isoDate,

src/popup/views/transactionDetail.js

@@ -18,10 +18,11 @@ const {
     copyableHtml,
     etherscanLinkHtml,
     explorerUrl,
+    endpointsByChainId,
     displaySymbol,
     goBack,
 } = require("./helpers");
-const { state, currentNetwork } = require("../../shared/state");
+const { state } = require("../../shared/state");
 const { nativeCurrencyByChainId } = require("../../shared/networks");
 const { formatEther, formatUnits } = require("ethers");
 const { log, debugFetch } = require("../../shared/log");
@@ -48,16 +49,16 @@ function getTransactionType(tx) {
     return "Native " + nativeCurrencyByChainId(tx.chainId) + " Transfer";
 }
 
-function txAddressHtml(address, ensName, title) {
+function txAddressHtml(address, ensName, title, chainId) {
     const blockie = blockieHtml(address);
     return (
         `<div class="mb-1">${blockie}</div>` +
-        renderAddressHtml(address, { title, ensName })
+        renderAddressHtml(address, { title, ensName, chainId })
     );
 }
 
-function txHashHtml(hash) {
-    const link = explorerUrl("tx", hash);
+function txHashHtml(hash, chainId) {
+    const link = explorerUrl("tx", hash, chainId);
     const extLink = etherscanLinkHtml(link);
     return copyableHtml(hash, "break-all") + extLink;
 }
@@ -83,10 +84,11 @@ function show(tx) {
             method: tx.method || null,
             contractAddress: tx.contractAddress || null,
             // The network the history entry was read from. The type line and
-            // the fee are in its native currency, not the active network's:
-            // the active network can change, in Settings or when the user
-            // approves a site's request, before a later popup shows this
-            // screen again.
+            // the fee are in its native currency, not the active network's,
+            // the links open its explorer, and the block, network details and
+            // calldata are read from its Blockscout: the active network can
+            // change, in Settings or when the user approves a site's request,
+            // before a later popup shows this screen again.
             chainId: tx.chainId,
         },
     };
@@ -96,18 +98,24 @@ function show(tx) {
 function render() {
     const tx = state.viewData.tx;
     if (!tx) return;
-    $("tx-detail-hash").innerHTML = txHashHtml(tx.hash);
+    $("tx-detail-hash").innerHTML = txHashHtml(tx.hash, tx.chainId);
 
     const fromTitle = addressTitle(tx.from, state.wallets);
     $("tx-detail-from").innerHTML = txAddressHtml(
         tx.from,
         tx.fromEns,
         fromTitle,
+        tx.chainId,
     );
     // A contract creation has no recipient: transactions.js gives it `to: ""`.
     if (tx.to) {
         const toTitle = addressTitle(tx.to, state.wallets);
-        $("tx-detail-to").innerHTML = txAddressHtml(tx.to, tx.toEns, toTitle);
+        $("tx-detail-to").innerHTML = txAddressHtml(
+            tx.to,
+            tx.toEns,
+            toTitle,
+            tx.chainId,
+        );
     } else {
         $("tx-detail-to").innerHTML = escapeHtml(CONTRACT_CREATION_TEXT);
     }
@@ -146,7 +154,7 @@ function render() {
     if (tokenContractSection && tokenContractEl) {
         if (tx.contractAddress) {
             const dot = addressDotHtml(tx.contractAddress);
-            const link = explorerUrl("token", tx.contractAddress);
+            const link = explorerUrl("token", tx.contractAddress, tx.chainId);
             // Hand-rolled rather than renderAddressHtml() because the
             // link goes to the explorer's /token/ page, not /address/.
             // Same two-row shape though: dot and link on the strip, the
@@ -204,7 +212,11 @@ function showDetailField(sectionId, contentId, value) {
 function populateOnChainDetails(txData, chainId) {
     // Block number
     if (txData.block_number != null) {
-        const blockLink = explorerUrl("block", String(txData.block_number));
+        const blockLink = explorerUrl(
+            "block",
+            String(txData.block_number),
+            chainId,
+        );
         const blockSection = $("tx-detail-block-section");
         const blockEl = $("tx-detail-block");
         if (blockSection && blockEl) {
@@ -301,8 +313,9 @@ async function loadFullTxDetails(txHash, chainId) {
     if (!section || !actionEl || !detailsEl) return;
 
     try {
+        const { blockscoutUrl } = endpointsByChainId(chainId);
         const resp = await debugFetch(
-            state.blockscoutUrl + "/transactions/" + txHash,
+            blockscoutUrl + "/transactions/" + txHash,
         );
         if (!resp.ok) return;
         const txData = await resp.json();
@@ -316,12 +329,12 @@ async function loadFullTxDetails(txHash, chainId) {
         // Decoded against the address the transaction was sent to, as the
         // explorer reports it, not the history entry's `to`: for a token
         // transfer that is the transfer's recipient, not the token contract.
-        // On the active network, the one whose explorer was just asked, and
-        // from the sender it reports.
+        // On the network the transaction was sent on, whose Blockscout was
+        // just asked, and from the sender it reports.
         const decoded = decodeCalldata(
             inputData,
             txData.to?.hash || "",
-            currentNetwork().chainId,
+            chainId,
             txData.from?.hash || "",
         );
         if (decoded) {
@@ -340,9 +353,9 @@ async function loadFullTxDetails(txHash, chainId) {
                     if (tokenSymbol) {
                         detailsHtml += `<div class="font-bold">${escapeHtml(displaySymbol(tokenSymbol))}</div>`;
                     }
-                    detailsHtml += renderAddressHtml(d.address);
+                    detailsHtml += renderAddressHtml(d.address, { chainId });
                 } else if (d.address) {
-                    detailsHtml += renderAddressHtml(d.address);
+                    detailsHtml += renderAddressHtml(d.address, { chainId });
                 } else {
                     detailsHtml += `<div class="font-bold">${escapeHtml(d.value)}</div>`;
                 }

src/popup/views/txStatus.js

@@ -14,10 +14,13 @@ const {
     displaySymbol,
     clearViewStack,
     tokenLabel,
+    reviewedNetworkProvider,
 } = require("./helpers");
 const { state } = require("../../shared/state");
-const { nativeCurrencyByChainId } = require("../../shared/networks");
-const { getProvider } = require("../../shared/balances");
+const {
+    SUPPORTED_CHAIN_IDS,
+    nativeCurrencyByChainId,
+} = require("../../shared/networks");
 const { log } = require("../../shared/log");
 
 // Receipt poll cadence and the deadline after which the wait is reported as
@@ -61,21 +64,22 @@ function endWait() {
 }
 
 // A contract creation reaches these screens with `to` as "" (approval.js
-// writes `to: toAddr || ""`).
-function toAddressHtml(address) {
+// writes `to: toAddr || ""`). The links below open the explorer of the network
+// with `chainId`, or of the active network when none is given.
+function toAddressHtml(address, chainId) {
     if (!address) return escapeHtml(CONTRACT_CREATION_TEXT);
     const title = addressTitle(address, state.wallets);
-    return renderAddressHtml(address, { title });
+    return renderAddressHtml(address, { title, chainId });
 }
 
-function txHashHtml(hash) {
-    const link = explorerUrl("tx", hash);
+function txHashHtml(hash, chainId) {
+    const link = explorerUrl("tx", hash, chainId);
     return copyableHtml(hash, "break-all") + etherscanLinkHtml(link);
 }
 
-function blockNumberHtml(blockNumber) {
+function blockNumberHtml(blockNumber, chainId) {
     const num = String(blockNumber);
-    const link = explorerUrl("block", num);
+    const link = explorerUrl("block", num, chainId);
     return copyableHtml(num) + etherscanLinkHtml(link);
 }
 
@@ -91,9 +95,11 @@ function startWait(txInfo, txHash, broadcastTime, pollNow) {
     // native currency of txInfo.chainId, the network the transaction was sent
     // on, not the active network's: the active network can change, in
     // Settings or when the user approves a site's request, while this screen
-    // is open or before a later popup resumes it. A null token is a swap whose
-    // amount was not decoded (see showTxApproval() in approval.js): the amount
-    // says so, and no symbol follows it.
+    // is open or before a later popup resumes it. The links on all three
+    // screens open that network's explorer, and this screen's receipt is
+    // asked of that network's node, for the same reason. A null token is a
+    // swap whose amount was not decoded (see showTxApproval() in
+    // approval.js): the amount says so, and no symbol follows it.
     let symbol = "";
     if (txInfo.token === "ETH") {
         symbol = nativeCurrencyByChainId(txInfo.chainId);
@@ -102,8 +108,8 @@ function startWait(txInfo, txHash, broadcastTime, pollNow) {
     }
     $("wait-tx-summary").textContent =
         txInfo.amount + (symbol ? " " + symbol : "");
-    $("wait-tx-to").innerHTML = toAddressHtml(txInfo.to);
-    $("wait-tx-hash").innerHTML = txHashHtml(txHash);
+    $("wait-tx-to").innerHTML = toAddressHtml(txInfo.to, txInfo.chainId);
+    $("wait-tx-hash").innerHTML = txHashHtml(txHash, txInfo.chainId);
     attachCopyHandlers("view-wait-tx");
 
     // Persisted so closing and reopening the popup resumes this wait
@@ -128,7 +134,7 @@ function startWait(txInfo, txHash, broadcastTime, pollNow) {
         renderElapsed();
     }, 1000);
 
-    const provider = getProvider(state.rpcUrl, state.networkId);
+    const provider = reviewedNetworkProvider(txInfo);
     let consecutiveFailures = 0;
 
     async function poll() {
@@ -207,10 +213,11 @@ function showWait(txInfo, txHash) {
 // an object merely missing one of them throws a TypeError out of
 // restoreView() — which init() does not guard, skipping the rest of popup
 // init and leaving wait-tx on screen with no back control. A non-numeric
-// broadcastTime leaves an unexitable wait counting "NaNs". txInfo.token,
-// txInfo.tokenSymbol and txInfo.chainId are deliberately unchecked: they are
-// compared and coalesced rather than dereferenced, and tokenSymbol is null for
-// ETH.
+// broadcastTime leaves an unexitable wait counting "NaNs". txInfo.chainId picks
+// the node the receipt is asked of and the explorer the links open, so it has
+// to name a network. txInfo.token and txInfo.tokenSymbol are deliberately
+// unchecked: they are compared and coalesced rather than dereferenced, and
+// tokenSymbol is null for ETH.
 function restoreWait() {
     const d = state.viewData;
     if (!d || !d.pendingWait) return false;
@@ -226,6 +233,7 @@ function restoreWait() {
     // path itself created.
     if (typeof info.to !== "string") return false;
     if (typeof info.amount !== "string") return false;
+    if (!SUPPORTED_CHAIN_IDS.has(info.chainId)) return false;
     if (typeof w.broadcastTime !== "number" || !isFinite(w.broadcastTime)) {
         return false;
     }
@@ -250,12 +258,13 @@ function showSuccess(txInfo, txHash, blockNumber) {
         hash: txHash,
         blockNumber: blockNumber,
         decoded: txInfo.decoded || null,
+        chainId: txInfo.chainId,
     };
     renderSuccess();
     ctx.doRefreshAndRender();
 }
 
-function decodedDetailsHtml(decoded) {
+function decodedDetailsHtml(decoded, chainId) {
     if (!decoded || !decoded.details) return "";
     let html = `<div class="border border-border border-dashed p-2 mb-3">`;
     if (decoded.name) {
@@ -271,11 +280,11 @@ function decodedDetailsHtml(decoded) {
         html += `<div class="text-xs text-muted mb-1">${escapeHtml(d.label)}</div>`;
         if (d.address) {
             if (d.isToken) {
-                const sym = tokenLabel(d.address) || "Unknown token";
+                const sym = tokenLabel(d.address, chainId) || "Unknown token";
                 html += `<div class="font-bold">${escapeHtml(sym)}</div>`;
-                html += toAddressHtml(d.address);
+                html += toAddressHtml(d.address, chainId);
             } else {
-                html += toAddressHtml(d.address);
+                html += toAddressHtml(d.address, chainId);
             }
         } else {
             html += `<div class="font-bold">${escapeHtml(d.value)}</div>`;
@@ -304,16 +313,16 @@ function renderSuccess() {
         toSection.classList.remove("hidden");
         $("success-tx-summary").textContent =
             d.amount + (d.symbol ? " " + d.symbol : "");
-        $("success-tx-to").innerHTML = toAddressHtml(d.to);
+        $("success-tx-to").innerHTML = toAddressHtml(d.to, d.chainId);
     }
 
-    $("success-tx-block").innerHTML = blockNumberHtml(d.blockNumber);
-    $("success-tx-hash").innerHTML = txHashHtml(d.hash);
+    $("success-tx-block").innerHTML = blockNumberHtml(d.blockNumber, d.chainId);
+    $("success-tx-hash").innerHTML = txHashHtml(d.hash, d.chainId);
 
     // Show decoded calldata details if present
     const decodedEl = $("success-tx-decoded");
     if (decodedEl && hasDecoded) {
-        decodedEl.innerHTML = decodedDetailsHtml(d.decoded);
+        decodedEl.innerHTML = decodedDetailsHtml(d.decoded, d.chainId);
         decodedEl.classList.remove("hidden");
     } else if (decodedEl) {
         decodedEl.classList.add("hidden");
@@ -339,6 +348,7 @@ function showError(txInfo, txHash, message) {
         to: txInfo.to,
         hash: txHash || null,
         message: message,
+        chainId: txInfo.chainId,
     };
     renderError();
 }
@@ -348,11 +358,11 @@ function renderError() {
     if (!d || !d.message) return;
     $("error-tx-summary").textContent =
         d.amount + (d.symbol ? " " + d.symbol : "");
-    $("error-tx-to").innerHTML = toAddressHtml(d.to);
+    $("error-tx-to").innerHTML = toAddressHtml(d.to, d.chainId);
     $("error-tx-message").textContent = d.message;
 
     if (d.hash) {
-        $("error-tx-hash").innerHTML = txHashHtml(d.hash);
+        $("error-tx-hash").innerHTML = txHashHtml(d.hash, d.chainId);
         $("error-tx-hash-section").classList.remove("hidden");
         attachCopyHandlers("view-error-tx");
     } else {

src/shared/uniswap.js

@@ -335,7 +335,8 @@ const UNNAMED_CURRENCY = "Unknown (not named in the calldata)";
 // commands this decoder does not read. That action names both of its
 // currencies, and those commands may name one, so saying the calldata did not
 // name it would be false. The Paid to line uses it too, when a step may pay an
-// address this decoder did not read.
+// address this decoder did not read, and so do the lines for what a step
+// takes from the sender, when this decoder does not know it.
 const UNDECODED_CURRENCY = "Unknown (could not be decoded)";
 
 // The Paid to line for each token paid to the router, the swap's output or
@@ -356,6 +357,11 @@ function present(value) {
     return value !== null && value !== undefined;
 }
 
+// Whether `a` and `b` are both known and the same address.
+function sameAddress(a, b) {
+    return present(a) && present(b) && a.toLowerCase() === b.toLowerCase();
+}
+
 // Uniswap V4 spells "use the whole open delta" as an amount of zero:
 // v4-periphery `src/libraries/ActionConstants.sol` declares
 // `uint128 internal constant OPEN_DELTA = 0` ("used to signal that an action
@@ -566,6 +572,7 @@ function decodeV2SwapExactIn(input) {
 // Decode V2_SWAP_EXACT_OUT (command 0x09) input bytes.
 // ABI: (address recipient, uint256 amountOut, uint256 amountInMax,
 //        address[] path, bool payerIsUser)
+// With `payerIsUser` false the router pays the input from its own balance.
 function decodeV2SwapExactOut(input) {
     try {
         const d = coder.decode(
@@ -578,6 +585,7 @@ function decodeV2SwapExactOut(input) {
             amountInMax: d[2],
             tokenIn: d[3][0],
             tokenOut: d[3][d[3].length - 1],
+            payerIsUser: d[4],
         };
     } catch {
         return null;
@@ -895,16 +903,22 @@ function totalAmount(amounts) {
 // input side from it only when no earlier step set it. A side it sets that
 // these rules leave unknown is set unknown, with no figure. A step with no
 // swap action sets only the sides SETTLE, SETTLE_ALL, TAKE and TAKE_ALL
-// name.
+// name. When the user pays the step any of Token In (`paidByUser` below),
+// decode() takes that, not the Amount of rule 2, as the step's amount.
 //
 // `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.
 // `recipientUnread` is set when the step has a payout this decoder did not
-// read. `settledFromRouter` is every SETTLE that the router pays from its own
-// balance (`payerIsUser` false), as its currency and the amount it pays: a
-// quantity, CONTRACT_BALANCE (all the router holds), or null when this
-// decoder cannot tell (see below).
+// read, and `settleUnread` when it has a SETTLE or SETTLE_ALL this decoder
+// did not read. `settledFromRouter` is every SETTLE that the router pays from
+// its own balance (`payerIsUser` false), as its currency and the amount it
+// pays: a quantity, CONTRACT_BALANCE (all the router holds), or null when
+// this decoder cannot tell (see below). `paidByUser` is what the user pays
+// the step, once per currency, as that currency and the amount: the total of
+// every SETTLE paid by the user (`payerIsUser` true) and every SETTLE_ALL,
+// which V4Router always has the user pay, of that currency, or null when
+// this decoder cannot tell what one of them pays.
 function decodeV4Swap(input) {
     try {
         const d = coder.decode(["bytes", "bytes[]"], input);
@@ -914,16 +928,18 @@ function decodeV4Swap(input) {
         let settleToken = null;
         let takeToken = null;
         const takes = [];
-        // Every SETTLE paid from the router, as its currency, its amount as
-        // written and its index among the step's actions.
-        const routerSettles = [];
-        // The currency of every SETTLE and SETTLE_ALL.
-        const settledCurrencies = [];
+        // Every SETTLE and SETTLE_ALL, as its currency, its amount as
+        // written, whether the user pays it, and its index among the step's
+        // actions. A SETTLE_ALL pays what a SETTLE of OPEN_DELTA (zero) paid
+        // by the user pays, all the step still owes of its currency, so it
+        // is kept as one; its maxAmount only caps that.
+        const settles = [];
         // The index of the step's last swap action, read or not, or -1.
         let lastSwapAction = -1;
         // Set when an action of the step could not be read.
         let actionUnread = false;
         let recipientUnread = false;
+        let settleUnread = false;
         // The step's swap actions that could be read, as decodeV4SwapAction()
         // reads them.
         const swaps = [];
@@ -942,19 +958,22 @@ function decodeV4Swap(input) {
                         params[i],
                     );
                     settleToken = s[0];
-                    settledCurrencies.push(s[0]);
-                    if (!s[2]) {
-                        routerSettles.push({
-                            currency: s[0],
-                            amount: s[1],
-                            index: i,
-                        });
-                    }
+                    settles.push({
+                        currency: s[0],
+                        amount: s[1],
+                        payerIsUser: s[2],
+                        index: i,
+                    });
                 } else if (actionId === V4_SETTLE_ALL) {
                     // SETTLE_ALL: (address currency, uint256 maxAmount)
                     const s = coder.decode(["address", "uint256"], params[i]);
                     settleToken = s[0];
-                    settledCurrencies.push(s[0]);
+                    settles.push({
+                        currency: s[0],
+                        amount: 0n,
+                        payerIsUser: true,
+                        index: i,
+                    });
                 } else if (actionId === V4_TAKE) {
                     // TAKE: (address currency, address recipient, uint256 amount)
                     const t = coder.decode(
@@ -996,7 +1015,8 @@ function decodeV4Swap(input) {
             } catch {
                 // Skip sub-actions we can't decode. A TAKE, TAKE_ALL or
                 // TAKE_PORTION among them is a payout this decoder did not
-                // read.
+                // read, and a SETTLE or SETTLE_ALL may take from the user
+                // what it did not read: the router still runs both.
                 actionUnread = true;
                 if (
                     actionId === V4_TAKE ||
@@ -1005,25 +1025,29 @@ function decodeV4Swap(input) {
                 ) {
                     recipientUnread = true;
                 }
+                if (actionId === V4_SETTLE || actionId === V4_SETTLE_ALL) {
+                    settleUnread = true;
+                }
             }
         }
 
-        // What each SETTLE paid from the router pays. A quantity or
-        // CONTRACT_BALANCE pays as written. A SETTLE of OPEN_DELTA (zero)
-        // pays whatever the step still owes of its currency when it runs.
-        // That is what the step's swap actions state they spend of it only
-        // in the plain shape of Uniswap's own routes, so only then is it
-        // given that amount: every action in the step was read; every swap
-        // action names the currency it spends and the one it buys (an
-        // exact-in action with an empty path swaps nothing); the SETTLE is
-        // the step's only SETTLE or SETTLE_ALL of its currency and comes
-        // after every swap action; no swap action buys that currency; and
-        // the swap actions that spend it state a quantity together (see
-        // totalAmount()). Otherwise it is given null.
-        const settledFromRouter = routerSettles.map((s) => {
-            if (s.amount !== 0n) {
-                return { currency: s.currency, amount: s.amount };
-            }
+        // What a SETTLE or SETTLE_ALL pays. A SETTLE of any amount but
+        // OPEN_DELTA (zero) pays as written: a quantity, or, for
+        // CONTRACT_BALANCE, as much as the router holds. A SETTLE of
+        // OPEN_DELTA, and a SETTLE_ALL, pay whatever the step still owes of
+        // the currency when they run. That is what the step's swap actions
+        // state they spend of it only in the plain shape of Uniswap's own
+        // routes, so only then is it given that amount: every action in the
+        // step was read; every swap action names the currency it spends and
+        // the one it buys (an exact-in action with an empty path swaps
+        // nothing); it is the step's only SETTLE or SETTLE_ALL of its
+        // currency and comes after every swap action; no swap action buys
+        // that currency and nothing in the step takes it (a TAKE of a stated
+        // amount adds to what the step owes); and the swap actions that spend
+        // it state a quantity together (see totalAmount()). Otherwise it is
+        // given null.
+        const pays = (s) => {
+            if (s.amount !== 0n) return s.amount;
             const stated = totalAmount(
                 swaps
                     .filter((w) => w.tokenIn === s.currency)
@@ -1032,16 +1056,30 @@ function decodeV4Swap(input) {
             const paysWhatSwapsSpend =
                 !actionUnread &&
                 swaps.every((w) => present(w.tokenIn) && present(w.tokenOut)) &&
-                settledCurrencies.filter((c) => c === s.currency).length ===
-                    1 &&
+                settles.filter((c) => c.currency === s.currency).length === 1 &&
                 s.index > lastSwapAction &&
                 !swaps.some((w) => w.tokenOut === s.currency) &&
+                !takes.some((t) => t.currency === s.currency) &&
                 typeof stated === "bigint";
-            return {
-                currency: s.currency,
-                amount: paysWhatSwapsSpend ? stated : null,
-            };
-        });
+            return paysWhatSwapsSpend ? stated : null;
+        };
+        const settledFromRouter = settles
+            .filter((s) => !s.payerIsUser)
+            .map((s) => ({ currency: s.currency, amount: pays(s) }));
+        const paidByUser = [];
+        for (const s of settles.filter((c) => c.payerIsUser)) {
+            const amount = pays(s);
+            const paid = paidByUser.find((p) => p.currency === s.currency);
+            if (!paid) {
+                paidByUser.push({ currency: s.currency, amount });
+            } else {
+                paid.amount =
+                    typeof paid.amount === "bigint" &&
+                    typeof amount === "bigint"
+                        ? paid.amount + amount
+                        : null;
+            }
+        }
 
         // Rule 3.
         if (swapUndecoded) {
@@ -1052,7 +1090,9 @@ function decodeV4Swap(input) {
                 amountOutMin: null,
                 takes,
                 settledFromRouter,
+                paidByUser,
                 recipientUnread,
+                settleUnread,
                 swapUndecoded,
                 hasSwapAction: true,
             };
@@ -1094,7 +1134,9 @@ function decodeV4Swap(input) {
             amountOutMin,
             takes,
             settledFromRouter,
+            paidByUser,
             recipientUnread,
+            settleUnread,
             swapUndecoded,
             hasSwapAction: swaps.length > 0,
         };
@@ -1125,6 +1167,13 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         let inputToken = null;
         let inputAmount = null;
         let inputEstablished = false;
+        // The last PERMIT2_PERMIT this decoder read, or null (see
+        // permitStands after the loop).
+        let permit = null;
+        // The index of each step this decoder did not read in full: a
+        // command it does not read, a step whose input it cannot read, in
+        // whole or in part, and one it fails on (see permitStands).
+        const stepsUnread = [];
         let outputToken = null;
         let minOutput = null;
         let outputEstablished = false;
@@ -1135,8 +1184,8 @@ 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. A figure is never rendered against a token that
-        // did not supply it.
+        // from the same hop, or from hops that all spend that token. 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
@@ -1152,7 +1201,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // states neither half: the output side always, and the input side
         // when no earlier hop set it. A half the establishing hop did not
         // state stays null and the line says so, rather than being filled in
-        // from a different hop.
+        // from a different hop. A PERMIT2_PERMIT sets no side here: after the
+        // loop, the last one read names Token In, and the Amount line is
+        // formed there, in one place (see permitStands).
         const setInput = (token, amount) => {
             inputToken = present(token) ? token : null;
             inputAmount = present(amount) ? amount : null;
@@ -1170,6 +1221,30 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             outputEstablished = true;
         };
 
+        // 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).
+        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
+        // nothing.
+        const addUserPaid = (token, amount) => {
+            if (amount !== ALREADY_PAID) userPaid.push({ token, amount });
+        };
+        // A step may take from the sender what this decoder did not read: a
+        // V4 step whose input or one of whose SETTLEs or SETTLE_ALLs it
+        // cannot read; a V2 or V3 exact-in or V2 exact-out step or
+        // PERMIT2_TRANSFER_FROM whose input it cannot read; a
+        // PERMIT2_TRANSFER_FROM_BATCH; a V3_SWAP_EXACT_OUT; an
+        // EXECUTE_SUB_PLAN; and a step it fails on. It is recorded with a null
+        // token and amount: one line says so, there is no Amount line, whose
+        // figure may then be too low, and the amount of a permit after it
+        // does not stand (see permitStands).
+        const spentUnread = () => {
+            userPaid.push({ token: null, amount: null });
+        };
+
         // Who the steps pay, in whichever step and of whatever token.
         // MSG_SENDER is the sender. The router itself, as ADDRESS_THIS or by
         // its own address, holds what it is paid until a later step pays it
@@ -1300,20 +1375,40 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     // EXECUTE_SUB_PLAN runs a further list of commands held in
                     // its input, which this decoder does not read. The step
                     // says so, and after this loop neither side is named.
-                    // Those commands may pay any address.
+                    // Those commands may pay any address and take from the
+                    // sender.
                     hasSubPlan = true;
                     commandNames[i] += " (its steps are not shown)";
                     payeeUnread = true;
+                    stepsUnread.push(i);
+                    spentUnread();
                 } else if (command === "PERMIT2_PERMIT") {
                     const p = decodePermit2(inputs[i]);
-                    // A permit states both halves itself, so it may replace an
-                    // input side an earlier hop established without breaking
-                    // the invariant.
-                    if (p) setInput(p.token, p.amount);
+                    if (p) {
+                        // Whether a step before it took its token, or may
+                        // have: the step that set the input side or one in
+                        // `userPaid`, when its token is the permit's or not
+                        // known.
+                        const mayBeItsToken = (token) =>
+                            !present(token) || sameAddress(token, p.token);
+                        const tookBefore =
+                            (inputEstablished && mayBeItsToken(inputToken)) ||
+                            userPaid.some((t) => mayBeItsToken(t.token));
+                        permit = {
+                            ...p,
+                            step: i,
+                            allowedToFail,
+                            beforeEveryTake: !tookBefore,
+                        };
+                    } else {
+                        stepsUnread.push(i);
+                    }
                 } else if (command === "PERMIT2_TRANSFER_FROM") {
                     const p = decodePermit2TransferFrom(inputs[i]);
                     if (!p) {
                         payeeUnread = true;
+                        stepsUnread.push(i);
+                        spentUnread();
                     } else if (
                         commandTypeMask === 0x1f &&
                         [MSG_SENDER, ADDRESS_THIS].includes(
@@ -1351,6 +1446,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         // owner may be any address. It sets no side, and the
                         // step says so.
                         commandNames[i] += " (could not be decoded)";
+                        stepsUnread.push(i);
                     } else if (b.owner.toLowerCase() !== sender) {
                         // The router reads the owner as written (see
                         // decodeBalanceCheck()), so address(1) and address(2)
@@ -1375,7 +1471,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                 } else if (command === "V3_SWAP_EXACT_IN") {
                     const s = decodeV3SwapExactIn(inputs[i]);
                     if (s) {
-                        setInputOnce(s.tokenIn, s.amountIn);
+                        if (!inputEstablished) {
+                            setInputOnce(s.tokenIn, s.amountIn);
+                        } else if (s.payerIsUser) {
+                            addUserPaid(s.tokenIn, s.amountIn);
+                        }
                         // Always update output: in multi-step swaps (V3 → V4),
                         // the last swap step determines the final output token
                         // and minimum received amount.
@@ -1388,11 +1488,25 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         }
                     } else {
                         payeeUnread = true;
+                        stepsUnread.push(i);
+                        spentUnread();
                     }
+                } else if (command === "V3_SWAP_EXACT_OUT") {
+                    // This decoder does not read it
+                    // (https://git.eeqj.de/sneak/AutistMask/issues/601). It
+                    // may pay any address and take from the sender, so
+                    // wherever it stands it leaves no Amount figure.
+                    payeeUnread = true;
+                    stepsUnread.push(i);
+                    spentUnread();
                 } else if (command === "V2_SWAP_EXACT_IN") {
                     const s = decodeV2SwapExactIn(inputs[i]);
                     if (s) {
-                        setInputOnce(s.tokenIn, s.amountIn);
+                        if (!inputEstablished) {
+                            setInputOnce(s.tokenIn, s.amountIn);
+                        } else if (s.payerIsUser) {
+                            addUserPaid(s.tokenIn, s.amountIn);
+                        }
                         setOutput(s.tokenOut, s.amountOutMin);
                         if (!s.payerIsUser) {
                             spendFromRouter(s.tokenIn, s.amountIn);
@@ -1402,20 +1516,34 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         }
                     } else {
                         payeeUnread = true;
+                        stepsUnread.push(i);
+                        spentUnread();
                     }
                 } else if (command === "V2_SWAP_EXACT_OUT") {
                     // Buys exactly amountOut and spends at most amountInMax.
                     hasV2ExactOut = true;
                     const s = decodeV2SwapExactOut(inputs[i]);
                     if (s) {
-                        setInputOnce(s.tokenIn, s.amountInMax);
+                        if (!inputEstablished) {
+                            setInputOnce(s.tokenIn, s.amountInMax);
+                        } else if (s.payerIsUser) {
+                            addUserPaid(s.tokenIn, s.amountInMax);
+                        }
                         setOutput(s.tokenOut, s.amountOut);
                         if (!isHop(i, s.tokenOut, s.recipient)) {
                             addPayee(s.recipient, s.tokenOut);
                         }
                     } else {
                         payeeUnread = true;
+                        stepsUnread.push(i);
+                        spentUnread();
                     }
+                } else if (command === "PERMIT2_TRANSFER_FROM_BATCH") {
+                    // It moves the sender's tokens to any addresses, and this
+                    // decoder does not read it.
+                    payeeUnread = true;
+                    stepsUnread.push(i);
+                    spentUnread();
                 } else if (command === "SWEEP") {
                     const s = decodeSweep(inputs[i]);
                     if (s) {
@@ -1425,6 +1553,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         }
                     } else {
                         payeeUnread = true;
+                        stepsUnread.push(i);
                     }
                 } else if (
                     command === "TRANSFER" ||
@@ -1461,6 +1590,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         }
                     } else {
                         payeeUnread = true;
+                        stepsUnread.push(i);
                     }
                 } else if (command === "ACROSS_V4_DEPOSIT_V3") {
                     const a = decodeAcrossV4DepositV3(inputs[i]);
@@ -1484,6 +1614,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         }
                     } else {
                         payeeUnread = true;
+                        stepsUnread.push(i);
                     }
                 } else if (command === "WRAP_ETH") {
                     const w = decodeWrapEth(inputs[i]);
@@ -1514,9 +1645,11 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         }
                     } else {
                         payeeUnread = true;
+                        stepsUnread.push(i);
                     }
                 } else if (command === "V4_SWAP") {
                     const v4 = decodeV4Swap(inputs[i]);
+                    const inputSetBefore = inputEstablished;
                     if (v4) {
                         // Each SETTLE paid from the router spends the amount
                         // decodeV4Swap() says it pays.
@@ -1532,12 +1665,28 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     if (!v4 || v4.recipientUnread) {
                         payeeUnread = true;
                     }
+                    if (
+                        !v4 ||
+                        v4.recipientUnread ||
+                        v4.settleUnread ||
+                        v4.swapUndecoded
+                    ) {
+                        stepsUnread.push(i);
+                    }
                     if (v4 && v4.swapUndecoded) {
                         // A swap action of this step went unread, so the step
                         // is marked.
                         swapUndecoded = true;
                         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
+                    // decodeV4Swap()), or, when the user pays none of it,
+                    // what its swap actions spend of it, whoever pays that.
+                    const paidIn = v4?.paidByUser.find(
+                        (p) => p.currency === v4.tokenIn,
+                    );
+                    const amountIn = paidIn ? paidIn.amount : v4?.amountIn;
                     if (v4 && v4.hasSwapAction) {
                         // A step with a swap action always sets the output
                         // side, as the last swap step wins, and sets the
@@ -1549,7 +1698,7 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         // token, likewise never sits beside an earlier step's
                         // other half.
                         if (!inputEstablished) {
-                            setInput(v4.tokenIn, v4.amountIn);
+                            setInput(v4.tokenIn, amountIn);
                         }
                         outputToken = v4.tokenOut;
                         minOutput = v4.amountOutMin;
@@ -1559,9 +1708,26 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         // SETTLE, SETTLE_ALL, TAKE or TAKE_ALL names:
                         // setInputOnce() and setOutput() leave alone a side
                         // whose two halves are both unstated.
-                        setInputOnce(v4.tokenIn, v4.amountIn);
+                        setInputOnce(v4.tokenIn, amountIn);
                         setOutput(v4.tokenOut, v4.amountOutMin);
                     }
+                    // Every V4 step, with a swap action or without, takes
+                    // from the sender what the user pays it (an amount an
+                    // unread action may change is null), less what the step
+                    // that sets the input side counts as its amount. One
+                    // whose input, or one of whose SETTLEs or SETTLE_ALLs,
+                    // this decoder could not read may take anything: the
+                    // router still runs it.
+                    const setInputHere = inputEstablished && !inputSetBefore;
+                    if (v4) {
+                        for (const p of v4.paidByUser) {
+                            if (setInputHere && p === paidIn) continue;
+                            addUserPaid(p.currency, p.amount);
+                        }
+                    }
+                    if (!v4 || v4.settleUnread) {
+                        spentUnread();
+                    }
                 } else if (command === "UNWRAP_WETH") {
                     hasUnwrapWeth = true;
                     const u = decodeUnwrapWeth(inputs[i]);
@@ -1582,26 +1748,109 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                         }
                     } else {
                         payeeUnread = true;
+                        stepsUnread.push(i);
                     }
                 } else {
                     // Any other step may pay an address this decoder does not
-                    // read: V3_SWAP_EXACT_OUT, PERMIT2_TRANSFER_FROM_BATCH and
-                    // the NFT commands among them, and a type the release
-                    // names no command for.
+                    // read: PERMIT2_PERMIT_BATCH and the NFT commands among
+                    // them, and a type the release names no command for.
                     payeeUnread = true;
+                    stepsUnread.push(i);
                 }
             } catch {
-                // Skip commands we can't decode. One may pay any address.
+                // Skip commands we can't decode. One may pay any address and
+                // take from the sender.
                 payeeUnread = true;
+                stepsUnread.push(i);
+                spentUnread();
             }
             if (allowedToFail) {
                 commandNames[i] += " (allowed to fail)";
             }
         }
 
+        // The Amount line, and the lines for what the steps take beyond it.
+        //
+        // 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
+        // quantity (a V4 open delta, ALREADY_PAID, or none stated), gets
+        // lines of its own. One whose amount is not known also leaves the
+        // total unknown, with no figure.
+        //
+        // The last PERMIT2_PERMIT read names Token In. Its amount stands as
+        // the Amount figure in place of the total only in the plain shape of
+        // Uniswap's own routes: it is the only PERMIT2_PERMIT, its spender is
+        // the router, the router may not let it fail, no step before it took
+        // its token or one not known, and this decoder read every step after
+        // it in full (see stepsUnread). Permit2 then lets the router take no
+        // more of the token than that amount, so the permit covers every take
+        // of it. A later step this decoder did not read may raise what Permit2
+        // lets the router take, as a PERMIT2_PERMIT_BATCH can. A step that
+        // may take from the sender what this decoder did not read leaves no
+        // figure, permit or not (see spentUnread()), and an EXECUTE_SUB_PLAN
+        // step leaves both sides unknown (below).
+        const stepCommands = Array.from(
+            commandsBytes,
+            (b) => commands[b & commandTypeMask],
+        );
+        const permitStands =
+            permit !== null &&
+            stepCommands.filter((c) => c === "PERMIT2_PERMIT").length === 1 &&
+            sameAddress(permit.spender, toAddress) &&
+            !permit.allowedToFail &&
+            permit.beforeEveryTake &&
+            !stepsUnread.some((step) => step > permit.step);
+        // What the steps take that the Amount line does not give, as
+        // { token, amount }. A null token is a step this decoder did not read
+        // (see spentUnread()), or a token it does not know.
+        const spentFromSender = [];
+        let total = null;
+        // The take of the step that set the input side, when the total
+        // starts from it and it stated no amount (see below), or null.
+        let firstTakeUnstated = null;
+        if (permit === null || sameAddress(inputToken, permit.token)) {
+            total = inputAmount;
+            if (inputEstablished && !present(inputAmount)) {
+                firstTakeUnstated = { token: inputToken, amount: null };
+            }
+        } else if (inputEstablished) {
+            // The step that set the input side spent a token other than the
+            // permit's, or one not known, so the total starts with no figure.
+            spentFromSender.push({ token: inputToken, amount: inputAmount });
+        }
+        if (permit !== null) inputToken = permit.token;
+        for (const t of userPaid) {
+            const ofTokenIn = sameAddress(t.token, inputToken);
+            if (ofTokenIn && permitStands) continue;
+            if (
+                ofTokenIn &&
+                typeof total === "bigint" &&
+                typeof t.amount === "bigint"
+            ) {
+                total += t.amount;
+                continue;
+            }
+            spentFromSender.push(t);
+            if (ofTokenIn && !present(t.amount)) total = null;
+        }
+        inputAmount = permitStands ? permit.amount : total;
+        // With no Amount figure, a later take's own figure could read as all
+        // that leaves, so the step that set the input side, when it stated
+        // no amount, then gets lines of its own too, first, saying its amount
+        // is not known.
+        if (
+            !present(inputAmount) &&
+            firstTakeUnstated !== null &&
+            spentFromSender.some((s) => present(s.amount))
+        ) {
+            spentFromSender.unshift(firstTakeUnstated);
+        }
+
         // The commands of an EXECUTE_SUB_PLAN step may spend the user's tokens
         // or pay the user, before or after any other step, and a permit among
-        // them would replace the input side. What the other steps state is
+        // them would name Token In. What the other steps state is
         // then not the whole swap, so both sides are set unknown, with no
         // figure, wherever the step stands.
         if (hasSubPlan) {
@@ -1672,37 +1921,49 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             });
         }
 
-        if (present(inputAmount)) {
-            // Three amounts need no scale to describe and are named rather
-            // than formatted: V4's open delta and 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.
-            let amount;
-            if (inputAmount === OPEN_DELTA) {
-                amount = { raw: OPEN_DELTA_AMOUNT, display: OPEN_DELTA_AMOUNT };
-            } else if (inputAmount === ALREADY_PAID) {
-                amount = {
+        // The text of an amount the swap steps spend, for the Amount line and
+        // the lines for other tokens below it. Three amounts need no scale to
+        // describe and are named rather than formatted: V4's open delta and
+        // 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.
+        const spentText = (amount, info) => {
+            if (amount === OPEN_DELTA) {
+                return { raw: OPEN_DELTA_AMOUNT, display: OPEN_DELTA_AMOUNT };
+            }
+            if (amount === ALREADY_PAID) {
+                return {
                     raw: ALREADY_PAID_AMOUNT,
                     display: ALREADY_PAID_AMOUNT,
                 };
-            } else if (inputAmount >= MAX_UINT160) {
-                amount = { raw: "Unlimited", display: "Unlimited" };
-            } else if (hasV2ExactOut) {
+            }
+            if (amount >= MAX_UINT160) {
+                return { raw: "Unlimited", display: "Unlimited" };
+            }
+            if (hasV2ExactOut) {
                 // A V2 exact-out swap spends at most this figure, whichever
-                // step set the line (its amountInMax, the WRAP_ETH of a swap
-                // paid in ETH, a permit), so it is said to be a maximum, in
-                // `raw` too: the wait, success and error screens show `raw` as
-                // the transaction's amount.
-                const most = amountText(inputAmount, inInfo);
-                amount = {
+                // steps gave it (an amountInMax, the WRAP_ETH of a swap paid
+                // in ETH, a permit, or several steps' total), so it is said to
+                // be a maximum, in `raw` too: the wait, success and error
+                // screens show `raw` as the transaction's amount.
+                const most = amountText(amount, info);
+                return {
                     raw: "Up to " + most.raw,
                     display: "Up to " + most.display,
                 };
-            } else {
-                amount = amountText(inputAmount, inInfo);
             }
+            return amountText(amount, info);
+        };
+
+        // A null token in `spentFromSender`, a step this decoder did not read
+        // or a token it does not know, leaves no Amount figure, which may
+        // then be too low.
+        if (
+            present(inputAmount) &&
+            spentFromSender.every((s) => present(s.token))
+        ) {
+            const amount = spentText(inputAmount, inInfo);
             details.push({
                 label: "Amount",
                 value: amount.display,
@@ -1710,6 +1971,26 @@ 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.
+        for (const s of spentFromSender) {
+            details.push({
+                label: "Moved from the sender",
+                value: present(s.amount)
+                    ? spentText(s.amount, tokenInfo(s.token, sources)).display
+                    : UNDECODED_CURRENCY,
+            });
+            if (present(s.token)) {
+                details.push(tokenMovedLine("Token moved", s.token, sources));
+                details.push({
+                    label: "Moved to",
+                    value: "The swap step that spends it",
+                });
+            }
+        }
+
         // 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) {

tests/approvalTokenNetwork.test.js

@@ -0,0 +1,270 @@
+// The approval screen for a site's Sepolia token transfer while Ethereum
+// Mainnet is active.
+//
+// The screen named the token, and scaled its amount, from the active network's
+// tracked tokens and balances, so a token the wallet tracks on Sepolia read as
+// an unknown token with its amount in base units, and the screens after it
+// labelled the amount `?` (https://git.eeqj.de/sneak/AutistMask/issues/629).
+// It now uses what the wallet knows of the tokens on the network the
+// transaction is for.
+//
+// Its address links opened the active network's explorer
+// (https://git.eeqj.de/sneak/AutistMask/issues/631). They now open the
+// explorer of the network the transaction is for.
+//
+// Driven through the real approval screen, password and Confirm included,
+// against a minimal DOM stub in the shape tests/swapStatusAmount.test.js uses.
+// The vault is mocked so that no password has to be hashed.
+
+jest.mock("../src/shared/vault", () => ({
+    decryptWithPassword: jest.fn(),
+}));
+
+globalThis.chrome = {
+    storage: { local: { get: async () => ({}), set: async () => {} } },
+};
+
+const { Interface } = require("ethers");
+const { state } = require("../src/shared/state");
+const { NETWORKS } = require("../src/shared/networks");
+const { decryptWithPassword } = require("../src/shared/vault");
+const approval = require("../src/popup/views/approval");
+const txStatus = require("../src/popup/views/txStatus");
+
+// A well-known test phrase, and its first address.
+const PHRASE = "test test test test test test test test test test test junk";
+const FROM = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+const RECIPIENT = "0x711e691962E5c054b78071C789A0C8CE657377aD";
+// A token the bundled token list does not name.
+const TOKEN = "0x74de5d4FCbf63E00296fd95d33236B9794016631";
+
+// FROM sends 1234.5 of the 6-decimal token to RECIPIENT.
+const TRANSFER_DATA = new Interface([
+    "function transfer(address to, uint256 amount)",
+]).encodeFunctionData("transfer", [RECIPIENT, 1234500000n]);
+
+function makeElement(id) {
+    const classes = new Set();
+    const el = {
+        id,
+        textContent: "",
+        value: "",
+        innerHTML: "",
+        disabled: false,
+        style: {},
+        dataset: {},
+        listeners: {},
+        classList: {
+            add: (...names) => names.forEach((n) => classes.add(n)),
+            remove: (...names) => names.forEach((n) => classes.delete(n)),
+            contains: (n) => classes.has(n),
+            toggle: (n, force) => {
+                const on = force === undefined ? !classes.has(n) : force;
+                if (on) classes.add(n);
+                else classes.delete(n);
+                return on;
+            },
+        },
+        addEventListener: (name, fn) => {
+            el.listeners[name] = el.listeners[name] || [];
+            el.listeners[name].push(fn);
+        },
+        querySelectorAll: () => [],
+        appendChild: () => {},
+    };
+    // Views reach for .parentElement to hide whole sections.
+    Object.defineProperty(el, "parentElement", {
+        get: () => node(id + "-parent"),
+    });
+    return el;
+}
+
+function makeDocument() {
+    const els = new Map();
+    return {
+        getElementById(id) {
+            // The debug banner is created on demand by helpers.js; absent
+            // is the state a non-debug, non-testnet popup is in.
+            if (id === "debug-banner") return null;
+            if (!els.has(id)) els.set(id, makeElement(id));
+            return els.get(id);
+        },
+        createElement: () => makeElement("created"),
+        body: { prepend: () => {} },
+    };
+}
+
+function node(id) {
+    return globalThis.document.getElementById(id);
+}
+
+function click(id) {
+    return Promise.all((node(id).listeners.click || []).map((fn) => fn()));
+}
+
+// One line of the decoded details: its label and what is drawn under it.
+function decodedLine(label) {
+    return node("approve-tx-decoded-details")
+        .innerHTML.split('<div class="mb-2">')
+        .find((line) =>
+            line.startsWith(`<div class="text-muted">${label}</div>`),
+        );
+}
+
+// Open the approval screen, with Ethereum Mainnet active and FROM holding
+// `tokenBalances` there, for the site's transaction sending TRANSFER_DATA to
+// the token, on Sepolia unless `chainId` names another chain. Confirm answers
+// the signed transaction with a failure, which leads to the error screen.
+async function showTokenTransfer(
+    tokenBalances = [],
+    chainId = NETWORKS.sepolia.chainId,
+) {
+    globalThis.document = makeDocument();
+    globalThis.window = { location: { search: "" }, close: () => {} };
+    globalThis.chrome.runtime = {
+        connect: () => ({ postMessage: () => {} }),
+        sendMessage: (msg, reply) => {
+            if (!reply) return;
+            if (msg.type !== "AUTISTMASK_GET_APPROVAL") {
+                return reply({
+                    error: "The transaction could not be sent.",
+                    retryable: false,
+                });
+            }
+            reply({
+                type: "tx",
+                origin: "https://dapp.example",
+                isPhishingDomain: false,
+                approvedFrom: FROM,
+                approvedTx: {
+                    type: 2,
+                    from: FROM,
+                    chainId,
+                    nonce: "0x7",
+                    gasLimit: "0x30d40",
+                    maxPriorityFeePerGas: "0x3b9aca00",
+                    maxFeePerGas: "0x77359400",
+                    to: TOKEN,
+                    value: "0x0",
+                    data: TRANSFER_DATA,
+                    accessList: [],
+                },
+            });
+        },
+    };
+    state.networkId = "mainnet";
+    state.activeAddress = FROM;
+    state.wallets = [
+        {
+            type: "hd",
+            name: "Wallet 1",
+            xpub: "xpub-wallet-1",
+            encryptedSecret: "encrypted-secret-1",
+            nextIndex: 1,
+            addresses: [
+                { address: FROM, index: 0, balance: "0", tokenBalances },
+            ],
+        },
+    ];
+    state.currentView = null;
+    txStatus.init({ doRefreshAndRender: () => {} });
+    approval.init({});
+    await approval.show(1);
+}
+
+async function confirm() {
+    decryptWithPassword.mockResolvedValue(PHRASE);
+    node("approve-tx-password").value = "any password";
+    await click("btn-approve-tx");
+}
+
+beforeEach(() => {
+    state.trackedTokens = [];
+    state.networkTrackedTokens = {};
+});
+
+describe("a token tracked on Sepolia only", () => {
+    beforeEach(() => {
+        state.networkTrackedTokens = {
+            sepolia: [{ address: TOKEN, symbol: "TDOL", decimals: 6 }],
+        };
+    });
+
+    test("is named on the Contract line and the decoded Token line, with its amount at its scale", async () => {
+        await showTokenTransfer();
+        expect(node("approve-tx-to").innerHTML).toContain(
+            '<div class="font-bold mb-1">TDOL</div>',
+        );
+        expect(decodedLine("Token")).toContain(
+            '<div class="font-bold">TDOL</div>',
+        );
+        expect(decodedLine("Amount")).toContain(
+            '<div class="font-bold">1234.5000 TDOL</div>',
+        );
+    });
+
+    test("labels the amount on the error screen that follows", async () => {
+        await showTokenTransfer();
+        await confirm();
+        expect(state.currentView).toBe("error-tx");
+        expect(node("error-tx-summary").textContent).toBe("1234.5000 TDOL");
+    });
+});
+
+// The same contract address on mainnet is another token, so what the wallet
+// tracks and holds there names nothing on Sepolia.
+test("a token tracked and held on mainnet only is not named, and its amount is in base units", async () => {
+    state.trackedTokens = [{ address: TOKEN, symbol: "MDOL", decimals: 18 }];
+    await showTokenTransfer([
+        { address: TOKEN, symbol: "MDOL", decimals: 18, balance: "1.0" },
+    ]);
+    expect(node("approve-tx-to").innerHTML).not.toContain("MDOL");
+    expect(decodedLine("Token")).toContain(
+        '<div class="font-bold">Unknown token</div>',
+    );
+    expect(decodedLine("Amount")).toContain(
+        '<div class="font-bold">1234500000 base units (decimals unknown)</div>',
+    );
+});
+
+// The From and Contract lines, and the decoded Token and Recipient lines.
+test("every address links to the Sepolia explorer", async () => {
+    await showTokenTransfer();
+    const sepolia = NETWORKS.sepolia.explorerUrl;
+    expect(node("approve-tx-from").innerHTML).toContain(
+        `href="${sepolia}/address/${FROM}"`,
+    );
+    expect(node("approve-tx-to").innerHTML).toContain(
+        `href="${sepolia}/address/${TOKEN}"`,
+    );
+    expect(decodedLine("Token")).toContain(
+        `href="${sepolia}/address/${TOKEN}"`,
+    );
+    expect(decodedLine("Recipient")).toContain(
+        `href="${sepolia}/address/${RECIPIENT}"`,
+    );
+    for (const id of [
+        "approve-tx-from",
+        "approve-tx-to",
+        "approve-tx-decoded-details",
+    ]) {
+        expect(node(id).innerHTML).not.toContain(NETWORKS.mainnet.explorerUrl);
+    }
+});
+
+// Chain id 1337 names no network here, so it has no explorer to link to.
+test("a transaction on a chain id that names no network is shown with no address links", async () => {
+    await showTokenTransfer([], "0x539");
+    expect(state.currentView).toBe("approve-tx");
+    expect(node("approve-tx-network").textContent).toBe(
+        "Unknown network (chain id 1337)",
+    );
+    expect(node("approve-tx-from").innerHTML).toContain(FROM);
+    for (const id of [
+        "approve-tx-from",
+        "approve-tx-to",
+        "approve-tx-decoded-details",
+    ]) {
+        expect(node(id).innerHTML).not.toContain("href=");
+    }
+});

tests/backNavigation.test.js

@@ -154,7 +154,14 @@ describe("Back onto a view the reopened popup never rendered", () => {
 
     test("Back onto the transaction detail renders it", () => {
         reopenedOn("settings", ["main", "transaction"], {
-            viewData: { tx: { hash: "0xdead", from: ADDRESS, to: ADDRESS } },
+            viewData: {
+                tx: {
+                    hash: "0xdead",
+                    from: ADDRESS,
+                    to: ADDRESS,
+                    chainId: "0x1",
+                },
+            },
         });
         goBack();
         expect(calls).toEqual(["transactionDetail"]);

tests/contractCreation.test.js

@@ -192,6 +192,7 @@ describe("the wait, success and error screens", () => {
         amount: "0.0000",
         token: "ETH",
         tokenSymbol: null,
+        chainId: "0x1",
     };
     const transfer = { ...creation, to: RECIPIENT };
 

tests/persistedFieldContract.test.js

@@ -441,6 +441,17 @@ const CONTRACT = [
                 views: ["error-tx"],
                 restored: false,
             },
+            // A chain id naming no network has no explorer to link to.
+            {
+                value: { hash: "0x1", to: ADDRESS, chainId: "0x5" },
+                views: ["success-tx"],
+                restored: false,
+            },
+            {
+                value: { message: "boom", to: ADDRESS, chainId: "0x5" },
+                views: ["error-tx"],
+                restored: false,
+            },
             // transaction passes on `data.tx`.
             {
                 value: { tx: { hash: "0x1" } },
@@ -454,6 +465,26 @@ const CONTRACT = [
                         from: ADDRESS,
                         to: ADDRESS,
                         contractAddress: 42,
+                        chainId: "0x1",
+                    },
+                },
+                views: ["transaction"],
+                restored: false,
+            },
+            // A transaction whose chain id is missing or names no network has
+            // no explorer to link to and no Blockscout to be read from.
+            {
+                value: { tx: { hash: "0x1", from: ADDRESS, to: ADDRESS } },
+                views: ["transaction"],
+                restored: false,
+            },
+            {
+                value: {
+                    tx: {
+                        hash: "0x1",
+                        from: ADDRESS,
+                        to: ADDRESS,
+                        chainId: "0x5",
                     },
                 },
                 views: ["transaction"],
@@ -812,7 +843,13 @@ const WELL_FORMED_DATA = {
     message: "boom",
     to: ADDRESS,
     decoded: { details: [{ address: TOKEN_ADDRESS }] },
-    tx: { hash: "0x1", from: ADDRESS, to: ADDRESS, contractAddress: null },
+    tx: {
+        hash: "0x1",
+        from: ADDRESS,
+        to: ADDRESS,
+        contractAddress: null,
+        chainId: "0x1",
+    },
     pendingTx: {
         token: "ETH",
         from: ADDRESS,
@@ -821,7 +858,7 @@ const WELL_FORMED_DATA = {
     },
     pendingWait: {
         hash: "0x1",
-        txInfo: { to: ADDRESS, amount: "1" },
+        txInfo: { to: ADDRESS, amount: "1", chainId: "0x1" },
         broadcastTime: BROADCAST_TIME,
     },
 };

tests/popupBoot.test.js

@@ -58,7 +58,7 @@ function restoringOnto(view, viewData) {
 test("the transaction screen's Blockscout request reaches the stub", async () => {
     const page = await bootPopup(
         restoringOnto("transaction", {
-            tx: { hash: "0x1", from: ADDRESS, to: ADDRESS },
+            tx: { hash: "0x1", from: ADDRESS, to: ADDRESS, chainId: "0x1" },
         }),
     );
 

tests/stateRecovery.test.js

@@ -225,7 +225,12 @@ describe("a popup already open when the stored profile becomes unreadable", () =
                 viewData: {
                     pendingWait: {
                         hash: "0x1",
-                        txInfo: { to: ADDRESS, amount: "1", token: "ETH" },
+                        txInfo: {
+                            to: ADDRESS,
+                            amount: "1",
+                            token: "ETH",
+                            chainId: "0x1",
+                        },
                         broadcastTime: Date.now(),
                     },
                 },

tests/tokenTransferDetail.test.js

@@ -8,6 +8,14 @@
 // tracks. It decodes against the address the explorer reports the transaction
 // was sent to.
 //
+// Its links open the explorer of the network the transaction was sent on,
+// whichever network is active
+// (https://git.eeqj.de/sneak/AutistMask/issues/584), and the transaction is
+// read from that network's Blockscout, the one Settings has for it
+// (https://git.eeqj.de/sneak/AutistMask/issues/623). Its decoded details name
+// the token, and scale its amount, from what the wallet knows of that
+// network's tokens (https://git.eeqj.de/sneak/AutistMask/issues/629).
+//
 // The row is the one the real history parser makes from the explorer's answer,
 // opened through transactionDetail.show(), which is what a click on the row
 // calls. Driven against a minimal DOM stub in the shape
@@ -22,10 +30,10 @@ jest.mock("../src/shared/log", () => ({
         warnf: () => {},
         errorf: () => {},
     },
-    debugFetch: async (url) => ({
-        ok: true,
-        json: async () => mockExplorerAnswer(url),
-    }),
+    debugFetch: async (url) => {
+        mockAsked.push(url);
+        return { ok: true, json: async () => mockExplorerAnswer(url) };
+    },
     setRuntimeDebug: () => {},
     isDebug: () => false,
 }));
@@ -35,10 +43,13 @@ globalThis.chrome = {
 };
 
 const { state } = require("../src/shared/state");
+const { NETWORKS } = require("../src/shared/networks");
 const { fetchRecentTransactions } = require("../src/shared/transactions");
 const transactionDetail = require("../src/popup/views/transactionDetail");
 
 const EXPLORER = "https://explorer.example/api/v2";
+// A Blockscout that knows nothing of the transaction.
+const OTHER_EXPLORER = "https://other-explorer.example/api/v2";
 const HOLDER = "0x0000000000000000000000000000000000000a11";
 const RECIPIENT = "0x711e691962E5c054b78071C789A0C8CE657377aD";
 // A token the wallet tracks and the bundled token list does not name.
@@ -51,6 +62,9 @@ const TRANSFER_DATA = new Interface([
     "function transfer(address to, uint256 amount)",
 ]).encodeFunctionData("transfer", [RECIPIENT, 1234500000n]);
 
+// Every URL asked of a Blockscout, in order.
+const mockAsked = [];
+
 // The explorer's answers: the transfer in HOLDER's token transfers, and the
 // transaction itself, sent to the token contract.
 function mockExplorerAnswer(url) {
@@ -77,7 +91,11 @@ function mockExplorerAnswer(url) {
         };
     }
     if (url === EXPLORER + "/transactions/" + TX_HASH) {
-        return { to: { hash: TOKEN }, raw_input: TRANSFER_DATA };
+        return {
+            to: { hash: TOKEN },
+            raw_input: TRANSFER_DATA,
+            block_number: 100,
+        };
     }
     return { items: [] };
 }
@@ -140,6 +158,7 @@ beforeEach(() => {
     globalThis.document = makeDocument();
     globalThis.window = { location: { search: "" } };
     state.blockscoutUrl = EXPLORER;
+    state.networkEndpoints = {};
     state.wallets = [
         {
             name: "Main",
@@ -148,13 +167,18 @@ beforeEach(() => {
         },
     ];
     state.trackedTokens = [{ address: TOKEN, symbol: "TDOL", decimals: 6 }];
+    state.networkTrackedTokens = {};
     state.viewData = {};
     state.viewStack = [];
     state.currentView = null;
 });
 
 test("a token transfer's decoded details name the token contract and the amount at its scale", async () => {
-    const [row] = await fetchRecentTransactions(HOLDER, EXPLORER, 1);
+    const [row] = await fetchRecentTransactions(
+        HOLDER,
+        EXPLORER,
+        NETWORKS.mainnet.chainId,
+    );
     expect(row.to).toBe(RECIPIENT);
     expect(row.contractAddress).toBe(TOKEN.toLowerCase());
 
@@ -174,3 +198,96 @@ test("a token transfer's decoded details name the token contract and the amount
         '<div class="font-bold">1234.5000 TDOL</div>',
     );
 });
+
+// Mainnet is active, and its Blockscout knows nothing of the transaction. The
+// row was read from the Blockscout Settings remembers for Sepolia, and the
+// screen reads the transaction from there too, so every link on it is drawn.
+test("with mainnet active, a Sepolia transaction is read from Sepolia's Blockscout and its links open the Sepolia explorer", async () => {
+    state.networkId = "mainnet";
+    state.blockscoutUrl = OTHER_EXPLORER;
+    state.networkEndpoints = { sepolia: { blockscoutUrl: EXPLORER } };
+    const [row] = await fetchRecentTransactions(
+        HOLDER,
+        EXPLORER,
+        NETWORKS.sepolia.chainId,
+    );
+
+    transactionDetail.show(row);
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
+
+    const sepolia = "https://sepolia.etherscan.io";
+    const links = (id) =>
+        [...node(id).innerHTML.matchAll(/href="([^"]*)"/g)].map((m) => m[1]);
+    expect(links("tx-detail-hash")).toEqual([`${sepolia}/tx/${TX_HASH}`]);
+    expect(links("tx-detail-from")).toEqual([`${sepolia}/address/${HOLDER}`]);
+    expect(links("tx-detail-to")).toEqual([`${sepolia}/address/${RECIPIENT}`]);
+    expect(links("tx-detail-token-contract")).toEqual([
+        `${sepolia}/token/${TOKEN.toLowerCase()}`,
+    ]);
+    expect(links("tx-detail-block")).toEqual([`${sepolia}/block/100`]);
+    expect(links("tx-detail-calldata-details")).toEqual([
+        `${sepolia}/address/${TOKEN}`,
+        `${sepolia}/address/${RECIPIENT}`,
+    ]);
+});
+
+test("with mainnet active and no Blockscout remembered for Sepolia, a Sepolia transaction is asked of Sepolia's default Blockscout", async () => {
+    state.networkId = "mainnet";
+    state.blockscoutUrl = OTHER_EXPLORER;
+    const [row] = await fetchRecentTransactions(
+        HOLDER,
+        EXPLORER,
+        NETWORKS.sepolia.chainId,
+    );
+    mockAsked.length = 0;
+
+    transactionDetail.show(row);
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
+
+    expect(mockAsked).toEqual([
+        NETWORKS.sepolia.defaultBlockscoutUrl + "/transactions/" + TX_HASH,
+    ]);
+});
+
+// Open the Sepolia transfer's detail screen with mainnet active, and wait for
+// its decoded details.
+async function showSepoliaTransferWithMainnetActive() {
+    state.networkId = "mainnet";
+    state.blockscoutUrl = OTHER_EXPLORER;
+    state.networkEndpoints = { sepolia: { blockscoutUrl: EXPLORER } };
+    const [row] = await fetchRecentTransactions(
+        HOLDER,
+        EXPLORER,
+        NETWORKS.sepolia.chainId,
+    );
+    transactionDetail.show(row);
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
+}
+
+test("with mainnet active, a Sepolia token transfer's decoded details name the token tracked on Sepolia and its amount at its scale", async () => {
+    state.trackedTokens = [];
+    state.networkTrackedTokens = {
+        sepolia: [{ address: TOKEN, symbol: "TDOL", decimals: 6 }],
+    };
+    await showSepoliaTransferWithMainnetActive();
+
+    expect(decodedLine("Token")).toContain('<div class="font-bold">TDOL</div>');
+    expect(decodedLine("Amount")).toContain(
+        '<div class="font-bold">1234.5000 TDOL</div>',
+    );
+});
+
+// The same contract address on mainnet is another token, so what the wallet
+// tracks and holds there names nothing on Sepolia.
+test("with mainnet active, a Sepolia token transfer's decoded details take nothing from mainnet's tracked tokens or balances", async () => {
+    state.trackedTokens = [{ address: TOKEN, symbol: "MDOL", decimals: 18 }];
+    state.wallets[0].addresses[0].tokenBalances = [
+        { address: TOKEN, symbol: "MDOL", decimals: 18, balance: "1.0" },
+    ];
+    await showSepoliaTransferWithMainnetActive();
+
+    expect(decodedLine("Token")).not.toContain("MDOL");
+    expect(decodedLine("Amount")).toContain(
+        '<div class="font-bold">1234500000 base units (decimals unknown)</div>',
+    );
+});

tests/txStatus.test.js

@@ -29,8 +29,13 @@ jest.mock("../src/shared/log", () => ({
 }));
 
 const mockReceiptLookup = jest.fn();
+// The RPC URL and network of every node a wait was given.
+const mockNodes = [];
 jest.mock("../src/shared/balances", () => ({
-    getProvider: () => ({ getTransactionReceipt: mockReceiptLookup }),
+    getProvider: (rpcUrl, networkId) => {
+        mockNodes.push({ rpcUrl, networkId });
+        return { getTransactionReceipt: mockReceiptLookup };
+    },
     refreshBalances: jest.fn(),
 }));
 
@@ -107,6 +112,7 @@ global.chrome = { storage };
 
 const txStatus = require("../src/popup/views/txStatus");
 const { state } = require("../src/shared/state");
+const { NETWORKS } = require("../src/shared/networks");
 const { RESTORABLE_VIEWS } = require("../src/shared/restorableViews");
 const { log } = require("../src/shared/log");
 
@@ -118,6 +124,7 @@ const TX_INFO = {
     amount: "0.0050",
     token: "ETH",
     tokenSymbol: null,
+    chainId: NETWORKS.mainnet.chainId,
 };
 
 // True when a view element is not hidden.
@@ -137,8 +144,14 @@ beforeEach(() => {
     jest.setSystemTime(new Date("2026-08-11T12:00:00Z"));
     elements.clear();
     mockReceiptLookup.mockReset();
+    mockNodes.length = 0;
     log.errorf.mockClear();
+    state.networkId = "mainnet";
+    state.rpcUrl = NETWORKS.mainnet.defaultRpcUrl;
+    state.networkEndpoints = {};
     state.wallets = [];
+    state.trackedTokens = [];
+    state.networkTrackedTokens = {};
     state.viewData = {};
     state.viewStack = [];
     state.currentView = null;
@@ -349,14 +362,14 @@ describe("WaitTx persistence across popup close", () => {
             // out of restoreView().
             {
                 hash: TX_HASH,
-                txInfo: { to: 42, amount: "0.0050" },
+                txInfo: { ...TX_INFO, to: 42 },
                 broadcastTime: Date.now(),
             },
             // Otherwise complete but an array: only Array.isArray() rejects
             // it, since typeof [] is "object" and the fields are present.
             {
                 hash: TX_HASH,
-                txInfo: Object.assign([], { to: RECIPIENT, amount: "0.0050" }),
+                txInfo: Object.assign([], TX_INFO),
                 broadcastTime: Date.now(),
             },
             {
@@ -364,6 +377,18 @@ describe("WaitTx persistence across popup close", () => {
                 txInfo: { to: RECIPIENT },
                 broadcastTime: Date.now(),
             },
+            // Otherwise complete but for a chain id naming no network: there
+            // is no node to ask for the receipt, and no explorer to link to.
+            {
+                hash: TX_HASH,
+                txInfo: { ...TX_INFO, chainId: undefined },
+                broadcastTime: Date.now(),
+            },
+            {
+                hash: TX_HASH,
+                txInfo: { ...TX_INFO, chainId: "0x5" },
+                broadcastTime: Date.now(),
+            },
         ]) {
             state.viewData = { pendingWait: bad };
             expect(txStatus.restoreWait()).toBe(false);
@@ -499,6 +524,154 @@ describe("WaitTx when the popup closes", () => {
     });
 });
 
+// The popup can reopen onto WaitTx after Settings switched the network. The
+// wait asked the active network's node for the receipt, never found it, and
+// reported a timeout, and its links went to the active network's explorer
+// (https://git.eeqj.de/sneak/AutistMask/issues/584).
+describe("WaitTx for a Sepolia transaction with mainnet active", () => {
+    const SEPOLIA_NODE = "https://sepolia.node.example.invalid";
+    const sepoliaTx = { ...TX_INFO, chainId: NETWORKS.sepolia.chainId };
+
+    beforeEach(() => {
+        state.rpcUrl = "https://mainnet.node.example.invalid";
+        state.networkEndpoints = { sepolia: { rpcUrl: SEPOLIA_NODE } };
+    });
+
+    test("the receipt is asked of the Sepolia node Settings has", async () => {
+        mockReceiptLookup.mockResolvedValue({ blockNumber: 21000000 });
+        state.viewData = {
+            pendingWait: {
+                txInfo: sepoliaTx,
+                hash: TX_HASH,
+                broadcastTime: Date.now(),
+            },
+        };
+        expect(txStatus.restoreWait()).toBe(true);
+        await jest.advanceTimersByTimeAsync(0);
+
+        expect(mockNodes).toEqual([
+            { rpcUrl: SEPOLIA_NODE, networkId: "sepolia" },
+        ]);
+        expect(state.currentView).toBe("success-tx");
+    });
+
+    test("the recipient and hash link to the Sepolia explorer", () => {
+        mockReceiptLookup.mockResolvedValue(null);
+        txStatus.showWait(sepoliaTx, TX_HASH);
+
+        expect(getElement("wait-tx-to").innerHTML).toContain(
+            `href="https://sepolia.etherscan.io/address/${RECIPIENT}"`,
+        );
+        expect(getElement("wait-tx-hash").innerHTML).toContain(
+            `href="https://sepolia.etherscan.io/tx/${TX_HASH}"`,
+        );
+    });
+});
+
+// SuccessTx and ErrorTx follow WaitTx and describe the same transaction, but
+// their links went to the active network's explorer
+// (https://git.eeqj.de/sneak/AutistMask/issues/622). Each test checks the
+// screen again after rendering it from its stored view data alone, as a
+// reopened popup does.
+describe("SuccessTx and ErrorTx for a Sepolia transaction with mainnet active", () => {
+    const SEPOLIA_EXPLORER = "https://sepolia.etherscan.io";
+    const TOKEN = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238";
+    const sepoliaTx = { ...TX_INFO, chainId: NETWORKS.sepolia.chainId };
+
+    test("the recipient, block and hash on SuccessTx link to the Sepolia explorer", async () => {
+        function expectSepoliaLinks() {
+            expect(getElement("success-tx-to").innerHTML).toContain(
+                `href="${SEPOLIA_EXPLORER}/address/${RECIPIENT}"`,
+            );
+            expect(getElement("success-tx-block").innerHTML).toContain(
+                `href="${SEPOLIA_EXPLORER}/block/21000000"`,
+            );
+            expect(getElement("success-tx-hash").innerHTML).toContain(
+                `href="${SEPOLIA_EXPLORER}/tx/${TX_HASH}"`,
+            );
+        }
+        mockReceiptLookup.mockResolvedValue({ blockNumber: 21000000 });
+        txStatus.showWait(sepoliaTx, TX_HASH);
+        await jest.advanceTimersByTimeAsync(10000);
+        expect(state.currentView).toBe("success-tx");
+        expectSepoliaLinks();
+
+        elements.clear();
+        txStatus.renderSuccess();
+        expectSepoliaLinks();
+    });
+
+    test("the addresses in SuccessTx's decoded action link to the Sepolia explorer", async () => {
+        function expectSepoliaLinks() {
+            const html = getElement("success-tx-decoded").innerHTML;
+            expect(html).toContain(
+                `href="${SEPOLIA_EXPLORER}/address/${TOKEN}"`,
+            );
+            expect(html).toContain(
+                `href="${SEPOLIA_EXPLORER}/address/${RECIPIENT}"`,
+            );
+        }
+        const decoded = {
+            name: "Transfer",
+            details: [
+                { label: "Token", address: TOKEN, isToken: true },
+                { label: "Recipient", address: RECIPIENT },
+            ],
+        };
+        mockReceiptLookup.mockResolvedValue({ blockNumber: 21000000 });
+        txStatus.showWait({ ...sepoliaTx, decoded }, TX_HASH);
+        await jest.advanceTimersByTimeAsync(10000);
+        expect(state.currentView).toBe("success-tx");
+        expectSepoliaLinks();
+
+        elements.clear();
+        txStatus.renderSuccess();
+        expectSepoliaLinks();
+    });
+
+    // https://git.eeqj.de/sneak/AutistMask/issues/629
+    test("SuccessTx's decoded action names the token from the tokens tracked on Sepolia", async () => {
+        function expectTokenNamed() {
+            expect(getElement("success-tx-decoded").innerHTML).toContain(
+                '<div class="font-bold">TDOL</div>',
+            );
+        }
+        state.networkTrackedTokens = {
+            sepolia: [{ address: TOKEN, symbol: "TDOL", decimals: 6 }],
+        };
+        const decoded = {
+            name: "Transfer",
+            details: [{ label: "Token", address: TOKEN, isToken: true }],
+        };
+        mockReceiptLookup.mockResolvedValue({ blockNumber: 21000000 });
+        txStatus.showWait({ ...sepoliaTx, decoded }, TX_HASH);
+        await jest.advanceTimersByTimeAsync(10000);
+        expect(state.currentView).toBe("success-tx");
+        expectTokenNamed();
+
+        elements.clear();
+        txStatus.renderSuccess();
+        expectTokenNamed();
+    });
+
+    test("the recipient and hash on ErrorTx link to the Sepolia explorer", () => {
+        function expectSepoliaLinks() {
+            expect(getElement("error-tx-to").innerHTML).toContain(
+                `href="${SEPOLIA_EXPLORER}/address/${RECIPIENT}"`,
+            );
+            expect(getElement("error-tx-hash").innerHTML).toContain(
+                `href="${SEPOLIA_EXPLORER}/tx/${TX_HASH}"`,
+            );
+        }
+        txStatus.showError(sepoliaTx, TX_HASH, "The transaction failed.");
+        expectSepoliaLinks();
+
+        elements.clear();
+        txStatus.renderError();
+        expectSepoliaLinks();
+    });
+});
+
 describe("wait-tx is a view the popup may reopen onto", () => {
     // The resume feature is wired through RESTORABLE_VIEWS: restoreView()
     // refuses any view not in the set, so dropping "wait-tx" from it kills

tests/uniswap.test.js

@@ -1289,6 +1289,961 @@ describe("uniswap decoder", () => {
         expect(detail(result, "Amount").value).not.toContain("500000000000");
     });
 
+    // https://git.eeqj.de/sneak/AutistMask/issues/625 — a route split across
+    // two swap steps the user pays for, with no PERMIT2_PERMIT, takes both
+    // steps' amounts from the wallet. On next at 671b4d3 the Amount line read
+    // only the first step's 600.0000 USDT.
+    describe("a swap split across steps the user pays for", () => {
+        const USDT_600 = 600000000n;
+        const USDT_400 = 400000000n;
+        const DAI_400 = 400000000000000000000n;
+        const OTHER_ADDR = "0x1111111111111111111111111111111111111111";
+        const UNDECODED = "Unknown (could not be decoded)";
+
+        // The lines between Token In and Token Out, as [label, value].
+        function linesBetweenTokens(result) {
+            const lines = result.details.map((d) => [d.label, d.value]);
+            const from = lines.findIndex(([label]) => label === "Token In");
+            const to = lines.findIndex(([label]) => label === "Token Out");
+            return lines.slice(from + 1, to);
+        }
+
+        // execute() of these command bytes and inputs, decoded as sent by
+        // the user.
+        function decodeSteps(commands, inputs) {
+            const data = buildExecute(
+                solidityPacked(
+                    commands.map(() => "uint8"),
+                    commands,
+                ),
+                inputs,
+                9999999999n,
+            );
+            return uniswap.decode(data, ROUTER_ADDR, "0x1", {}, USER_ADDR);
+        }
+
+        // The first step: a V3 exact-in of 600 USDT for USDC, paid by the
+        // user, which sets the input side.
+        const V3_600 = encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
+            USDT_ADDR,
+            USDC_ADDR,
+        ]);
+        // V4 SETTLE of `amount` of `currency`, and TAKE of `amount` of
+        // `currency` to `recipient`.
+        const settle = (currency, amount, payerIsUser) =>
+            coder.encode(
+                ["address", "uint256", "bool"],
+                [currency, amount, payerIsUser],
+            );
+        const take = (currency, recipient, amount) =>
+            coder.encode(
+                ["address", "address", "uint256"],
+                [currency, recipient, amount],
+            );
+        // `input` with the top byte of its word at `index` set. This decoder
+        // cannot read such a word as an address or a length; the router reads
+        // its low bytes and runs the step.
+        const dirtyWord = (input, index) => {
+            const at = 2 + index * 64;
+            return input.slice(0, at) + "ff" + input.slice(at + 2);
+        };
+
+        test("a split across a V3 and a V2 step the user pays for shows the total", () => {
+            const data = buildExecute(
+                solidityPacked(["uint8", "uint8"], [0x00, 0x08]),
+                [
+                    encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
+                        USDT_ADDR,
+                        USDC_ADDR,
+                    ]),
+                    encodeV2SwapExactIn(USER_ADDR, USDT_400, 390000000n, [
+                        USDT_ADDR,
+                        USDC_ADDR,
+                    ]),
+                ],
+                9999999999n,
+            );
+
+            const result = uniswap.decode(
+                data,
+                ROUTER_ADDR,
+                "0x1",
+                {},
+                USER_ADDR,
+            );
+            expect(result).not.toBeNull();
+
+            expect(detail(result, "Token In").address.toLowerCase()).toBe(
+                USDT_ADDR.toLowerCase(),
+            );
+            expect(detail(result, "Amount").value).toBe("1000.0000 USDT");
+            expect(detail(result, "Amount").rawValue).toBe("1000.0000");
+            expect(detail(result, "Moved from the sender")).toBeUndefined();
+        });
+
+        // In the order of Uniswap's own V4 routes: the swap, then a SETTLE of
+        // OPEN_DELTA by the user, which pays what the swap spends.
+        test("a split across a V3 step and a V4 step the user pays for shows the total", () => {
+            const data = buildExecute(
+                solidityPacked(["uint8", "uint8"], [0x00, 0x10]),
+                [
+                    encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
+                        USDT_ADDR,
+                        USDC_ADDR,
+                    ]),
+                    encodeV4Swap(
+                        new Uint8Array([
+                            V4_SWAP_EXACT_IN_SINGLE_ID,
+                            V4_SETTLE_ID,
+                            V4_TAKE_ID,
+                        ]),
+                        [
+                            encodeV4ExactInSingle(
+                                USDT_ADDR,
+                                USDC_ADDR,
+                                USDT_400,
+                                390000000n,
+                            ),
+                            encodeV4Settle(USDT_ADDR), // paid by the user
+                            encodeV4Take(USDC_ADDR),
+                        ],
+                    ),
+                ],
+                9999999999n,
+            );
+
+            const result = uniswap.decode(
+                data,
+                ROUTER_ADDR,
+                "0x1",
+                {},
+                USER_ADDR,
+            );
+            expect(result).not.toBeNull();
+
+            expect(detail(result, "Amount").value).toBe("1000.0000 USDT");
+            expect(detail(result, "Moved from the sender")).toBeUndefined();
+        });
+
+        test("a second step the user pays for that spends another token shows that token's amount", () => {
+            const data = buildExecute(
+                solidityPacked(["uint8", "uint8"], [0x00, 0x08]),
+                [
+                    encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
+                        USDT_ADDR,
+                        USDC_ADDR,
+                    ]),
+                    encodeV2SwapExactIn(
+                        USER_ADDR,
+                        400000000000000000000n, // 400 DAI
+                        390000000n,
+                        [DAI_ADDR, USDC_ADDR],
+                    ),
+                ],
+                9999999999n,
+            );
+
+            const result = uniswap.decode(
+                data,
+                ROUTER_ADDR,
+                "0x1",
+                {},
+                USER_ADDR,
+            );
+            expect(result).not.toBeNull();
+
+            expect(linesBetweenTokens(result)).toEqual([
+                ["Amount", "600.0000 USDT"],
+                ["Moved from the sender", "400.0000 DAI"],
+                ["Token moved", "DAI (" + DAI_ADDR + ")"],
+                ["Moved to", "The swap step that spends it"],
+            ]);
+        });
+
+        // Every later V4 step takes from the sender what its SETTLEs paid by
+        // the user and its SETTLE_ALLs pay, each currency on its own, with a
+        // swap action or without. Each of these read 600.0000 USDT alone
+        // before.
+        const USDT_FOR_USDC_400 = encodeV4ExactInSingle(
+            USDT_ADDR,
+            USDC_ADDR,
+            USDT_400,
+            390000000n,
+        );
+        const DAI_FOR_USDC_400 = encodeV4ExactInSingle(
+            DAI_ADDR,
+            USDC_ADDR,
+            DAI_400,
+            390000000n,
+        );
+        const DAI_GROUP = [
+            ["Moved from the sender", "400.0000 DAI"],
+            ["Token moved", "DAI (" + DAI_ADDR + ")"],
+            ["Moved to", "The swap step that spends it"],
+        ];
+        test.each([
+            {
+                kind: "a V4 step paying USDT and DAI by a SETTLE_ALL of each",
+                actions: [
+                    V4_SWAP_EXACT_IN_SINGLE_ID,
+                    V4_SWAP_EXACT_IN_SINGLE_ID,
+                    V4_SETTLE_ALL_ID,
+                    V4_SETTLE_ALL_ID,
+                    V4_TAKE_ALL_ID,
+                ],
+                params: [
+                    USDT_FOR_USDC_400,
+                    DAI_FOR_USDC_400,
+                    encodeV4SettleAll(USDT_ADDR, USDT_400),
+                    encodeV4SettleAll(DAI_ADDR, DAI_400),
+                    encodeV4TakeAll(USDC_ADDR, 0n),
+                ],
+                lines: [["Amount", "1000.0000 USDT"], ...DAI_GROUP],
+            },
+            {
+                kind: "a V4 step with a SETTLE of USDT by the user, then a SETTLE of WETH from the router",
+                actions: [
+                    V4_SETTLE_ID,
+                    V4_SETTLE_ID,
+                    V4_SWAP_EXACT_IN_SINGLE_ID,
+                    V4_SWAP_EXACT_IN_SINGLE_ID,
+                    V4_TAKE_ALL_ID,
+                ],
+                params: [
+                    settle(USDT_ADDR, USDT_400, true),
+                    settle(WETH_ADDR, 2n ** 255n, false), // CONTRACT_BALANCE
+                    USDT_FOR_USDC_400,
+                    encodeV4ExactInSingle(WETH_ADDR, USDC_ADDR, 0n, 1n),
+                    encodeV4TakeAll(USDC_ADDR, 0n),
+                ],
+                lines: [["Amount", "1000.0000 USDT"]],
+            },
+            {
+                kind: "a V4 step with no swap action: a SETTLE of 400 USDT by the user and a TAKE of it to another address",
+                actions: [V4_SETTLE_ID, V4_TAKE_ID],
+                params: [
+                    settle(USDT_ADDR, USDT_400, true),
+                    take(USDT_ADDR, OTHER_ADDR, USDT_400),
+                ],
+                lines: [["Amount", "1000.0000 USDT"]],
+            },
+            // The SETTLE's amount, not the swap's, is what the user pays.
+            {
+                kind: "a V4 step swapping 400 USDT with a SETTLE of 5,000 USDT by the user, the rest taken to another address",
+                actions: [
+                    V4_SETTLE_ID,
+                    V4_SWAP_EXACT_IN_SINGLE_ID,
+                    V4_TAKE_ID,
+                    V4_TAKE_ALL_ID,
+                ],
+                params: [
+                    settle(USDT_ADDR, 5000000000n, true),
+                    USDT_FOR_USDC_400,
+                    take(USDT_ADDR, OTHER_ADDR, 0n),
+                    encodeV4TakeAll(USDC_ADDR, 0n),
+                ],
+                lines: [["Amount", "5600.0000 USDT"]],
+            },
+            // A SETTLE_ALL pays all the step owes, here what the TAKE takes as
+            // well as what the swap spends, so its amount is not known.
+            {
+                kind: "a V4 step with no swap action: a TAKE of 400 USDT to another address, then a SETTLE_ALL of USDT",
+                actions: [V4_TAKE_ID, V4_SETTLE_ALL_ID],
+                params: [
+                    take(USDT_ADDR, OTHER_ADDR, USDT_400),
+                    encodeV4SettleAll(USDT_ADDR, USDT_400),
+                ],
+                lines: [
+                    ["Moved from the sender", UNDECODED],
+                    ["Token moved", "USDT (" + USDT_ADDR + ")"],
+                    ["Moved to", "The swap step that spends it"],
+                ],
+            },
+            {
+                kind: "a V4 step swapping 400 USDT, with a TAKE of 400 USDT to another address before its SETTLE_ALL of USDT",
+                actions: [
+                    V4_SWAP_EXACT_IN_SINGLE_ID,
+                    V4_TAKE_ID,
+                    V4_SETTLE_ALL_ID,
+                    V4_TAKE_ALL_ID,
+                ],
+                params: [
+                    USDT_FOR_USDC_400,
+                    take(USDT_ADDR, OTHER_ADDR, USDT_400),
+                    encodeV4SettleAll(USDT_ADDR, 800000000n),
+                    encodeV4TakeAll(USDC_ADDR, 0n),
+                ],
+                lines: [
+                    ["Moved from the sender", UNDECODED],
+                    ["Token moved", "USDT (" + USDT_ADDR + ")"],
+                    ["Moved to", "The swap step that spends it"],
+                ],
+            },
+        ])(
+            "a V3 step of 600 USDT, then $kind",
+            ({ actions, params, lines }) => {
+                const result = decodeSteps(
+                    [0x00, 0x10],
+                    [V3_600, encodeV4Swap(new Uint8Array(actions), params)],
+                );
+                expect(linesBetweenTokens(result)).toEqual(lines);
+            },
+        );
+
+        // https://git.eeqj.de/sneak/AutistMask/issues/628 — the V4 step that
+        // sets the input side takes what its SETTLE paid by the user states,
+        // not what its swap spends. Each of these read 400.0000 USDT before;
+        // on next the first two read 400.0000 USDT and 1.0000 USDT.
+        const V4_SETTLE_5000 = encodeV4Swap(
+            new Uint8Array([
+                V4_SETTLE_ID,
+                V4_SWAP_EXACT_IN_SINGLE_ID,
+                V4_TAKE_ID,
+                V4_TAKE_ALL_ID,
+            ]),
+            [
+                settle(USDT_ADDR, 5000000000n, true),
+                USDT_FOR_USDC_400,
+                take(USDT_ADDR, OTHER_ADDR, 0n), // the rest
+                encodeV4TakeAll(USDC_ADDR, 0n),
+            ],
+        );
+        test.each([
+            {
+                kind: "a V4 step swapping 400 USDT with a SETTLE of 5,000 USDT by the user, the rest taken to another address,",
+                commands: [0x10],
+                inputs: [V4_SETTLE_5000],
+            },
+            {
+                kind: "a PERMIT2_PERMIT of 1 USDT that the router may let fail, then that V4 step,",
+                commands: [0x8a, 0x10],
+                inputs: [
+                    encodePermit2(USDT_ADDR, 1000000n, ROUTER_ADDR),
+                    V4_SETTLE_5000,
+                ],
+            },
+            // The unread SWEEP keeps the permit's amount from standing.
+            {
+                kind: "a PERMIT2_PERMIT of 5,000 USDT to the router, that V4 step, then a SWEEP that cannot be read,",
+                commands: [0x0a, 0x10, 0x04],
+                inputs: [
+                    encodePermit2(USDT_ADDR, 5000000000n, ROUTER_ADDR),
+                    V4_SETTLE_5000,
+                    dirtyWord(
+                        coder.encode(
+                            ["address", "address", "uint256"],
+                            [USDC_ADDR, USER_ADDR, 0n],
+                        ),
+                        1,
+                    ),
+                ],
+            },
+        ])("$kind shows the 5,000 USDT", ({ commands, inputs }) => {
+            const result = decodeSteps(commands, inputs);
+            expect(linesBetweenTokens(result)).toEqual([
+                ["Amount", "5000.0000 USDT"],
+            ]);
+        });
+
+        // A step that may take from the sender what the decoder did not read
+        // leaves no Amount figure, which may be too low, and one line says so.
+        const UNREAD_SWAP = V4_SWAP_ACTION_SHAPES[0].newer;
+        test.each([
+            {
+                kind: "a V4 step whose SETTLE by the user cannot be read",
+                actions: [
+                    V4_SWAP_EXACT_IN_SINGLE_ID,
+                    V4_SETTLE_ID,
+                    V4_TAKE_ALL_ID,
+                ],
+                params: [
+                    USDT_FOR_USDC_400,
+                    dirtyWord(settle(USDT_ADDR, USDT_400, true), 0),
+                    encodeV4TakeAll(USDC_ADDR, 0n),
+                ],
+            },
+            {
+                kind: "a V4 step whose SETTLE_ALL cannot be read",
+                actions: [
+                    V4_SWAP_EXACT_IN_SINGLE_ID,
+                    V4_SETTLE_ALL_ID,
+                    V4_TAKE_ALL_ID,
+                ],
+                params: [
+                    USDT_FOR_USDC_400,
+                    dirtyWord(encodeV4SettleAll(USDT_ADDR, USDT_400), 0),
+                    encodeV4TakeAll(USDC_ADDR, 0n),
+                ],
+            },
+            {
+                kind: "a V4 step whose swap action and SETTLE_ALL cannot be read",
+                actions: [
+                    V4_SWAP_EXACT_IN_SINGLE_ID,
+                    V4_SETTLE_ALL_ID,
+                    V4_TAKE_ALL_ID,
+                ],
+                params: [
+                    UNREAD_SWAP,
+                    dirtyWord(encodeV4SettleAll(WETH_ADDR, ONE_WETH), 0),
+                    encodeV4TakeAll(USDC_ADDR, 0n),
+                ],
+            },
+        ])("a V3 step of 600 USDT, then $kind", ({ actions, params }) => {
+            const result = decodeSteps(
+                [0x00, 0x10],
+                [V3_600, encodeV4Swap(new Uint8Array(actions), params)],
+            );
+            expect(linesBetweenTokens(result)).toEqual([
+                ["Moved from the sender", UNDECODED],
+            ]);
+        });
+
+        test.each([
+            {
+                kind: "a V4 step swapping 400 USDT whose SETTLE by the user cannot be read",
+                commands: [0x10],
+                inputs: [
+                    encodeV4Swap(
+                        new Uint8Array([
+                            V4_SWAP_EXACT_IN_SINGLE_ID,
+                            V4_SETTLE_ID,
+                            V4_TAKE_ALL_ID,
+                        ]),
+                        [
+                            USDT_FOR_USDC_400,
+                            dirtyWord(settle(USDT_ADDR, USDT_400, true), 0),
+                            encodeV4TakeAll(USDC_ADDR, 0n),
+                        ],
+                    ),
+                ],
+            },
+            {
+                kind: "a V3 step of 600 USDT, then a V4 step whose input cannot be read",
+                commands: [0x00, 0x10],
+                inputs: [
+                    V3_600,
+                    dirtyWord(
+                        encodeV4Swap(new Uint8Array([V4_SETTLE_ID]), [
+                            settle(USDT_ADDR, USDT_400, true),
+                        ]),
+                        2,
+                    ),
+                ],
+            },
+            {
+                kind: "a V4 step with no swap action whose SETTLE_ALL cannot be read, then a V3 step of 600 USDT",
+                commands: [0x10, 0x00],
+                inputs: [
+                    encodeV4Swap(
+                        new Uint8Array([V4_TAKE_ID, V4_SETTLE_ALL_ID]),
+                        [
+                            take(USDT_ADDR, OTHER_ADDR, USDT_400),
+                            dirtyWord(
+                                encodeV4SettleAll(USDT_ADDR, USDT_400),
+                                0,
+                            ),
+                        ],
+                    ),
+                    V3_600,
+                ],
+            },
+            {
+                kind: "a V3 step of 600 USDT, then a V2 step the user pays for whose input cannot be read",
+                commands: [0x00, 0x08],
+                inputs: [
+                    V3_600,
+                    dirtyWord(
+                        encodeV2SwapExactIn(OTHER_ADDR, USDT_400, 1n, [
+                            USDT_ADDR,
+                            USDC_ADDR,
+                        ]),
+                        0,
+                    ),
+                ],
+            },
+            {
+                kind: "a V3 step of 600 USDT, then a PERMIT2_TRANSFER_FROM whose input cannot be read",
+                commands: [0x00, 0x02],
+                inputs: [
+                    V3_600,
+                    dirtyWord(
+                        coder.encode(
+                            ["address", "address", "uint160"],
+                            [USDT_ADDR, OTHER_ADDR, USDT_400],
+                        ),
+                        1,
+                    ),
+                ],
+            },
+            {
+                kind: "a V3 step of 600 USDT, then a PERMIT2_TRANSFER_FROM_BATCH",
+                commands: [0x00, 0x0d],
+                inputs: [
+                    V3_600,
+                    coder.encode(
+                        ["tuple(address,address,uint160,address)[]"],
+                        [[[USER_ADDR, OTHER_ADDR, USDT_400, USDT_ADDR]]],
+                    ),
+                ],
+            },
+        ])("$kind", ({ commands, inputs }) => {
+            const result = decodeSteps(commands, inputs);
+            expect(linesBetweenTokens(result)).toEqual([
+                ["Moved from the sender", UNDECODED],
+            ]);
+        });
+
+        // The steps of an EXECUTE_SUB_PLAN may take from the sender too, so
+        // wherever it stands one line says so, and the figure of another
+        // take cannot read as all that leaves.
+        const SUB_PLAN = encodeSubPlan("0x00", [V3_600]);
+        const V2_DAI_400 = encodeV2SwapExactIn(USER_ADDR, DAI_400, 390000000n, [
+            DAI_ADDR,
+            USDC_ADDR,
+        ]);
+        test.each([
+            {
+                kind: "a V3 step of 600 USDT and a V2 step of 400 DAI, then an EXECUTE_SUB_PLAN",
+                commands: [0x00, 0x08, 0x21],
+                inputs: [V3_600, V2_DAI_400, SUB_PLAN],
+                lines: [
+                    ["Moved from the sender", "400.0000 DAI"],
+                    ["Token moved", "DAI (" + DAI_ADDR + ")"],
+                    ["Moved to", "The swap step that spends it"],
+                    ["Moved from the sender", UNDECODED],
+                ],
+            },
+            {
+                kind: "an EXECUTE_SUB_PLAN, then a V3 step of 600 USDT and a V2 step of 400 DAI",
+                commands: [0x21, 0x00, 0x08],
+                inputs: [SUB_PLAN, V3_600, V2_DAI_400],
+                lines: [
+                    ["Moved from the sender", UNDECODED],
+                    ["Moved from the sender", "400.0000 DAI"],
+                    ["Token moved", "DAI (" + DAI_ADDR + ")"],
+                    ["Moved to", "The swap step that spends it"],
+                ],
+            },
+            {
+                kind: "a V3 step of 600 USDT and a PERMIT2_TRANSFER_FROM of 400 DAI, then an EXECUTE_SUB_PLAN",
+                commands: [0x00, 0x02, 0x21],
+                inputs: [
+                    V3_600,
+                    coder.encode(
+                        ["address", "address", "uint160"],
+                        [DAI_ADDR, OTHER_ADDR, DAI_400],
+                    ),
+                    SUB_PLAN,
+                ],
+                lines: [
+                    ["Moved from the sender", UNDECODED],
+                    ["Moved from the sender", "400.0000 DAI"],
+                    ["Token moved", "DAI (" + DAI_ADDR + ")"],
+                    ["Moved to", OTHER_ADDR],
+                ],
+            },
+        ])("$kind", ({ commands, inputs, lines }) => {
+            const result = decodeSteps(commands, inputs);
+            expect(linesBetweenTokens(result)).toEqual(lines);
+        });
+
+        // A PERMIT2_PERMIT in the plain shape of Uniswap's own routes keeps
+        // its own amount: Permit2 lets the router take no more of the token,
+        // so the steps after it do not add to it.
+        test("a split after a PERMIT2_PERMIT shows the permit's amount", () => {
+            const data = buildExecute(
+                solidityPacked(["uint8", "uint8", "uint8"], [0x0a, 0x00, 0x08]),
+                [
+                    encodePermit2(USDT_ADDR, 5000000000n, ROUTER_ADDR), // 5000 USDT
+                    encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
+                        USDT_ADDR,
+                        USDC_ADDR,
+                    ]),
+                    encodeV2SwapExactIn(USER_ADDR, USDT_400, 390000000n, [
+                        USDT_ADDR,
+                        USDC_ADDR,
+                    ]),
+                ],
+                9999999999n,
+            );
+
+            const result = uniswap.decode(
+                data,
+                ROUTER_ADDR,
+                "0x1",
+                {},
+                USER_ADDR,
+            );
+            expect(result).not.toBeNull();
+
+            expect(detail(result, "Amount").value).toBe("5000.0000 USDT");
+            expect(detail(result, "Moved from the sender")).toBeUndefined();
+        });
+
+        // Out of that shape the permit caps nothing the Amount line can rely
+        // on, so the line gives the total the steps take, as with no permit.
+        const ONE_USDT_PERMIT = (spender) =>
+            encodePermit2(USDT_ADDR, 1000000n, spender);
+        test.each([
+            {
+                kind: "to another spender",
+                commands: [0x0a],
+                permits: [ONE_USDT_PERMIT(OTHER_ADDR)],
+            },
+            {
+                kind: "that the router lets fail",
+                commands: [0x8a],
+                permits: [ONE_USDT_PERMIT(ROUTER_ADDR)],
+            },
+            {
+                kind: "followed by a second one",
+                commands: [0x0a, 0x0a],
+                permits: [
+                    ONE_USDT_PERMIT(ROUTER_ADDR),
+                    ONE_USDT_PERMIT(ROUTER_ADDR),
+                ],
+            },
+        ])(
+            "a split after a PERMIT2_PERMIT $kind shows the total the steps take",
+            ({ commands, permits }) => {
+                const result = decodeSteps(
+                    [...commands, 0x00, 0x08],
+                    [
+                        ...permits,
+                        V3_600,
+                        encodeV2SwapExactIn(USER_ADDR, USDT_400, 390000000n, [
+                            USDT_ADDR,
+                            USDC_ADDR,
+                        ]),
+                    ],
+                );
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "1000.0000 USDT"],
+                ]);
+            },
+        );
+
+        // A PERMIT2_PERMIT_BATCH, which this decoder does not read, may raise
+        // what the router may take of the permit's token again.
+        test("a split after a PERMIT2_PERMIT and a PERMIT2_PERMIT_BATCH shows the total the steps take", () => {
+            const permitBatch = coder.encode(
+                [
+                    "tuple(tuple(address,uint160,uint48,uint48)[],address,uint256)",
+                    "bytes",
+                ],
+                [
+                    [
+                        [[USDT_ADDR, 10000000000n, 0, 0]], // 10,000 USDT
+                        ROUTER_ADDR,
+                        9999999999,
+                    ],
+                    "0x1234",
+                ],
+            );
+            const result = decodeSteps(
+                [0x0a, 0x03, 0x00, 0x08],
+                [
+                    encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
+                    permitBatch,
+                    V3_600,
+                    encodeV2SwapExactIn(USER_ADDR, 9400000000n, 1n, [
+                        USDT_ADDR,
+                        USDC_ADDR,
+                    ]),
+                ],
+            );
+            expect(linesBetweenTokens(result)).toEqual([
+                ["Amount", "10000.0000 USDT"],
+            ]);
+        });
+
+        // Any other step this decoder does not read may do the same, for
+        // example through the hook of the pool a V4_INITIALIZE_POOL sets up.
+        test.each([
+            {
+                kind: "a V4_INITIALIZE_POOL",
+                command: 0x13,
+                input: coder.encode(
+                    [POOL_KEY, "uint160"],
+                    [
+                        [USDC_ADDR, USDT_ADDR, 3000, 60, OTHER_ADDR],
+                        79228162514264337593543950336n,
+                    ],
+                ),
+            },
+            {
+                kind: "a SWEEP whose input cannot be read",
+                command: 0x04,
+                input: dirtyWord(
+                    coder.encode(
+                        ["address", "address", "uint256"],
+                        [USDC_ADDR, USER_ADDR, 0n],
+                    ),
+                    1,
+                ),
+            },
+        ])(
+            "a split after a PERMIT2_PERMIT, with $kind between its steps, shows the total the steps take",
+            ({ command, input }) => {
+                const result = decodeSteps(
+                    [0x0a, 0x00, command, 0x08],
+                    [
+                        encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
+                        V3_600,
+                        input,
+                        encodeV2SwapExactIn(USER_ADDR, 9400000000n, 1n, [
+                            USDT_ADDR,
+                            USDC_ADDR,
+                        ]),
+                    ],
+                );
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "10000.0000 USDT"],
+                ]);
+            },
+        );
+
+        // A V3_SWAP_EXACT_OUT the user pays for, of at most `amountInMax`
+        // USDT for USDC. Its input is (recipient, amountOut, amountInMax,
+        // path, payerIsUser), laid out as encodeV3SwapExactIn() writes one;
+        // an exact-out path lists the token bought first.
+        const v3ExactOut = (amountInMax) =>
+            encodeV3SwapExactIn(USER_ADDR, 390000000n, amountInMax, [
+                USDC_ADDR,
+                USDT_ADDR,
+            ]);
+        // A split exact-out route: a V3_SWAP_EXACT_OUT of at most 6,000 USDT
+        // and a V2_SWAP_EXACT_OUT of at most 4,000 USDT, both paid by the
+        // user, then a SWEEP of USDC to the user.
+        const EXACT_OUT_SPLIT = [
+            v3ExactOut(6000000000n),
+            encodeV2SwapExactOut(USER_ADDR, 390000000n, 4000000000n, [
+                USDT_ADDR,
+                USDC_ADDR,
+            ]),
+            coder.encode(
+                ["address", "address", "uint256"],
+                [USDC_ADDR, USER_ADDR, 0n],
+            ),
+        ];
+        // This decoder does not read a V3_SWAP_EXACT_OUT, so what one takes
+        // leaves no Amount figure wherever it stands, and a permit's amount
+        // does not stand.
+        test.each([
+            {
+                kind: "a V3 exact-in of 600 USDT, then a V3_SWAP_EXACT_OUT",
+                commands: [0x00, 0x01],
+                inputs: [V3_600, v3ExactOut(USDT_400)],
+            },
+            {
+                kind: "a PERMIT2_PERMIT of 10,000 USDT, then a V3_SWAP_EXACT_OUT, a V2_SWAP_EXACT_OUT and a SWEEP",
+                commands: [0x0a, 0x01, 0x09, 0x04],
+                inputs: [
+                    encodePermit2(USDT_ADDR, 10000000000n, ROUTER_ADDR),
+                    ...EXACT_OUT_SPLIT,
+                ],
+            },
+            {
+                kind: "a V3_SWAP_EXACT_OUT, a V2_SWAP_EXACT_OUT and a SWEEP",
+                commands: [0x01, 0x09, 0x04],
+                inputs: EXACT_OUT_SPLIT,
+            },
+            {
+                kind: "a V3_SWAP_EXACT_OUT of at most 9,400 USDT, then a PERMIT2_PERMIT of 600 USDT and a V3 exact-in of 600 USDT",
+                commands: [0x01, 0x0a, 0x00],
+                inputs: [
+                    v3ExactOut(9400000000n),
+                    encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
+                    V3_600,
+                ],
+            },
+        ])(
+            "$kind, all paid by the user, shows no Amount figure",
+            ({ commands, inputs }) => {
+                const result = decodeSteps(commands, inputs);
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Moved from the sender", UNDECODED],
+                ]);
+            },
+        );
+
+        // A later step's amount that cannot be added to the Amount line,
+        // because the amount of the step that set the input side is not a
+        // quantity, gets lines of its own. When that step stated no amount,
+        // it gets lines of its own too, saying so, so the 400 USDT cannot
+        // read as all that leaves.
+        const V2_EXACT_OUT_400 = encodeV2SwapExactOut(
+            USER_ADDR,
+            390000000n,
+            USDT_400,
+            [USDT_ADDR, USDC_ADDR],
+        );
+        const UP_TO_400_USDT = [
+            ["Moved from the sender", "Up to 400.0000 USDT"],
+            ["Token moved", "USDT (" + USDT_ADDR + ")"],
+            ["Moved to", "The swap step that spends it"],
+        ];
+        const UNKNOWN_USDT = [
+            ["Moved from the sender", UNDECODED],
+            ["Token moved", "USDT (" + USDT_ADDR + ")"],
+            ["Moved to", "The swap step that spends it"],
+        ];
+        // A V4 exact-out step of at most 600 USDT for 1 WETH, in the shape
+        // of Uniswap's own routes: a SETTLE of OPEN_DELTA by the user pays
+        // what the swap spends.
+        const V4_EXACT_OUT_600 = encodeV4Swap(
+            new Uint8Array([
+                V4_SWAP_EXACT_OUT_SINGLE_ID,
+                V4_SETTLE_ID,
+                V4_TAKE_ALL_ID,
+            ]),
+            [
+                encodeV4ExactOutSingle(
+                    USDT_ADDR,
+                    WETH_ADDR,
+                    ONE_WETH,
+                    USDT_600,
+                ),
+                encodeV4Settle(USDT_ADDR),
+                encodeV4TakeAll(WETH_ADDR, 0n),
+            ],
+        );
+        test.each([
+            {
+                kind: "a V4 exact-out step with a SETTLE of OPEN_DELTA by the user",
+                commands: [0x10, 0x09],
+                first: V4_EXACT_OUT_600,
+                lines: [...UNKNOWN_USDT, ...UP_TO_400_USDT],
+            },
+            // Settled by the user, the step's amount would be what that
+            // SETTLE pays, which the decoder cannot state here.
+            {
+                kind: "a V4 exact-in step of the open delta, settled from the router",
+                commands: [0x10, 0x09],
+                first: encodeV4Swap(
+                    new Uint8Array([
+                        V4_SWAP_EXACT_IN_SINGLE_ID,
+                        V4_SETTLE_ID,
+                        V4_TAKE_ALL_ID,
+                    ]),
+                    [
+                        encodeV4ExactInSingle(USDT_ADDR, USDC_ADDR, 0n, 1n),
+                        settle(USDT_ADDR, 0n, false),
+                        encodeV4TakeAll(USDC_ADDR, 0n),
+                    ],
+                ),
+                lines: [
+                    ["Amount", "All available (V4 open delta)"],
+                    ...UP_TO_400_USDT,
+                ],
+            },
+            {
+                kind: "a V2 exact-in step of ALREADY_PAID",
+                commands: [0x08, 0x09],
+                first: encodeV2SwapExactIn(USER_ADDR, 0n, 1n, [
+                    USDT_ADDR,
+                    USDC_ADDR,
+                ]),
+                lines: [
+                    [
+                        "Amount",
+                        "Whatever an earlier step sent to the pair (V2 already paid)",
+                    ],
+                    ...UP_TO_400_USDT,
+                ],
+            },
+        ])(
+            "$kind, then a V2 exact-out of at most 400 USDT the user pays for, shows the 400 USDT",
+            ({ commands, first, lines }) => {
+                const result = decodeSteps(commands, [first, V2_EXACT_OUT_400]);
+                expect(linesBetweenTokens(result)).toEqual(lines);
+            },
+        );
+
+        // The V4 exact-out route above the other way round, where the later
+        // take's unknown amount leaves no figure at all, and other ways the
+        // step that sets the input side states no amount.
+        test.each([
+            {
+                kind: "a V2 exact-out of at most 400 USDT, then a V4 exact-out step of at most 600 USDT",
+                commands: [0x09, 0x10],
+                inputs: [V2_EXACT_OUT_400, V4_EXACT_OUT_600],
+                lines: UNKNOWN_USDT,
+            },
+            {
+                kind: "a PERMIT2_PERMIT of 1 USDT to another spender, a V4 exact-out step of at most 600 USDT, then a V2 exact-out of at most 400 USDT",
+                commands: [0x0a, 0x10, 0x09],
+                inputs: [
+                    encodePermit2(USDT_ADDR, 1000000n, OTHER_ADDR),
+                    V4_EXACT_OUT_600,
+                    V2_EXACT_OUT_400,
+                ],
+                lines: [...UNKNOWN_USDT, ...UP_TO_400_USDT],
+            },
+            {
+                kind: "a V4 step whose swap action cannot be read, with a SETTLE of WETH by the user, then a V2 exact-out of at most 400 USDT",
+                commands: [0x10, 0x09],
+                inputs: [
+                    encodeV4Swap(
+                        new Uint8Array([
+                            V4_SWAP_EXACT_IN_SINGLE_ID,
+                            V4_SETTLE_ID,
+                            V4_TAKE_ALL_ID,
+                        ]),
+                        [
+                            UNREAD_SWAP,
+                            encodeV4Settle(WETH_ADDR),
+                            encodeV4TakeAll(USDC_ADDR, 0n),
+                        ],
+                    ),
+                    V2_EXACT_OUT_400,
+                ],
+                lines: [
+                    ["Moved from the sender", UNDECODED],
+                    ["Token moved", "WETH (" + WETH_ADDR + ")"],
+                    ["Moved to", "The swap step that spends it"],
+                    ...UP_TO_400_USDT,
+                ],
+            },
+        ])(
+            "$kind, all paid by the user, shows that an amount is not known",
+            ({ commands, inputs, lines }) => {
+                const result = decodeSteps(commands, inputs);
+                expect(linesBetweenTokens(result)).toEqual(lines);
+            },
+        );
+
+        // A V2 exact-out step makes every amount the swap steps spend a maximum,
+        // the total included.
+        test("a split with a V2 exact-out step the user pays for shows the total as a maximum", () => {
+            const data = buildExecute(
+                solidityPacked(["uint8", "uint8"], [0x00, 0x09]),
+                [
+                    encodeV3SwapExactIn(USER_ADDR, USDT_600, 590000000n, [
+                        USDT_ADDR,
+                        USDC_ADDR,
+                    ]),
+                    encodeV2SwapExactOut(USER_ADDR, 390000000n, USDT_400, [
+                        USDT_ADDR,
+                        USDC_ADDR,
+                    ]),
+                ],
+                9999999999n,
+            );
+
+            const result = uniswap.decode(
+                data,
+                ROUTER_ADDR,
+                "0x1",
+                {},
+                USER_ADDR,
+            );
+            expect(result).not.toBeNull();
+
+            expect(detail(result, "Amount").value).toBe("Up to 1000.0000 USDT");
+        });
+    });
+
     // https://git.eeqj.de/sneak/AutistMask/issues/359 — the output half, in
     // the shape the issue measured: a V4 step that states a minimum of zero
     // and names no output currency.
@@ -1403,7 +2358,9 @@ describe("uniswap decoder", () => {
     // (v4-periphery ActionConstants.OPEN_DELTA = 0, applied by V4Router's
     // _swapExactInputSingle / _swapExactInput). It is not a quantity, and
     // printing "0.0000 WETH" for it would state the exact inverse of what the
-    // step does. Against c9ebac8 the Amount line was omitted entirely.
+    // step does. Against c9ebac8 the Amount line was omitted entirely. The
+    // SETTLE is paid from the router: one paid by the user would make the
+    // step's amount what that SETTLE pays.
     test("a V4 open-delta amountIn is named, not printed as zero", () => {
         const data = buildExecute(
             "0x10",
@@ -1415,7 +2372,10 @@ describe("uniswap decoder", () => {
                         V4_TAKE_ID,
                     ]),
                     [
-                        encodeV4Settle(WETH_ADDR),
+                        coder.encode(
+                            ["address", "uint256", "bool"],
+                            [WETH_ADDR, 0n, false],
+                        ),
                         encodeV4ExactInSingle(
                             WETH_ADDR,
                             USDC_ADDR,

tests/uniswapRecipient.test.js

@@ -671,6 +671,7 @@ describe("any token left in the router is not received", () => {
                 v3SwapExactIn(MSG_SENDER, USDT_2000, USDC_1990, USDT, USDC),
             ),
             left: tokenLine(WETH, "WETH"),
+            spent: "2000.0000 USDT",
         },
         {
             kind: "a WRAP_ETH of 1 ETH into the router, then a swap of 0.5 WETH from the router",
@@ -697,6 +698,7 @@ describe("any token left in the router is not received", () => {
                 v2Swap(0x08, MSG_SENDER, ONE_WETH, USDC_1990, [WETH, USDC]),
             ),
             left: tokenLine(WETH, "WETH"),
+            spent: "1.0000 WETH",
         },
         {
             kind: "a WRAP_ETH of 1 ETH into the router, then a V3 swap of 1 WETH that the user pays for",
@@ -705,6 +707,7 @@ describe("any token left in the router is not received", () => {
                 v3SwapExactIn(MSG_SENDER, ONE_WETH, USDC_1990, WETH, USDC),
             ),
             left: tokenLine(WETH, "WETH"),
+            spent: "1.0000 WETH",
         },
         {
             kind: "a WRAP_ETH of 1 ETH into the router, then a V4 swap of 1 WETH with a SETTLE of 1 WETH by the user",
@@ -717,6 +720,7 @@ describe("any token left in the router is not received", () => {
                 ),
             ),
             left: tokenLine(WETH, "WETH"),
+            spent: "1.0000 WETH",
         },
         {
             kind: "a swap paying WETH to the router, a WRAP_ETH of 1 ETH into the router, then a swap of 1 WETH from the router",
@@ -792,9 +796,13 @@ describe("any token left in the router is not received", () => {
                 ),
             ),
             left: tokenLine(WETH, "WETH"),
+            // The step has two SETTLEs of WETH, so what the user pays is not
+            // known.
+            spent: UNDECODED,
         },
         // The user pays for the swap by a SETTLE_ALL or SETTLE whose currency
-        // the decoder cannot read, so the SETTLE from the router pays nothing.
+        // the decoder cannot read, so the SETTLE from the router pays nothing,
+        // and what the user pays is not known.
         {
             kind: "a WRAP_ETH of 1 ETH into the router, then a V4 swap of 1 WETH with a SETTLE_ALL that cannot be read and a SETTLE of OPEN_DELTA from the router",
             data: execute(
@@ -807,6 +815,7 @@ describe("any token left in the router is not received", () => {
                 ),
             ),
             left: tokenLine(WETH, "WETH"),
+            unread: true,
         },
         {
             kind: "a WRAP_ETH of 1 ETH into the router, then a V4 swap of 1 WETH with a SETTLE by the user that cannot be read and a SETTLE of OPEN_DELTA from the router",
@@ -820,6 +829,7 @@ describe("any token left in the router is not received", () => {
                 ),
             ),
             left: tokenLine(WETH, "WETH"),
+            unread: true,
         },
         {
             kind: "a WRAP_ETH of 1 ETH into the router, then a V4 step with an exact-in of 1 WETH less 1,000 wei and an empty path, a swap of 1,000 wei, and a SETTLE of OPEN_DELTA from the router",
@@ -873,12 +883,20 @@ describe("any token left in the router is not received", () => {
             ),
             left: { label: "Token moved into the router", value: "ETH" },
         },
-    ])("$kind", ({ data, left }) => {
+    ])("$kind", ({ data, left, spent, unread }) => {
         const result = decode(data);
         expect(labels(result)).toEqual([
             "Protocol",
             "Token In",
-            "Amount",
+            // A later step whose SETTLE or SETTLE_ALL the decoder cannot read
+            // may take anything from the sender: one line says so, in place
+            // of the Amount line (https://git.eeqj.de/sneak/AutistMask/issues/625).
+            unread ? "Moved from the sender" : "Amount",
+            // A later swap step the user pays for spends `spent` of a token
+            // other than Token In.
+            ...(spent
+                ? ["Moved from the sender", "Token moved", "Moved to"]
+                : []),
             "Token Out",
             "Paid to",
             "Token moved into the router",
@@ -886,6 +904,14 @@ describe("any token left in the router is not received", () => {
             "Steps",
             "Deadline",
         ]);
+        if (spent) {
+            expect(detail(result, "Moved from the sender").value).toBe(spent);
+        }
+        if (unread) {
+            expect(detail(result, "Moved from the sender").value).toBe(
+                UNDECODED,
+            );
+        }
         expect(paidTo(result)).toEqual([STAYS_IN_ROUTER]);
         expect(detail(result, "Token moved into the router")).toEqual(left);
         expect(detail(result, "Min. paid out").value).toBe("1990.0000 USDC");

tests/uniswapRouterAddress.test.js

@@ -186,14 +186,14 @@ function node(id) {
     return globalThis.document.getElementById(id);
 }
 
-// Open the transaction detail screen with Sepolia active, for the
-// transaction the explorer reports sent to `sentTo`, and wait for its
+// Open the transaction detail screen with `activeNetworkId` active, for the
+// Sepolia transaction the explorer reports sent to `sentTo`, and wait for its
 // decoded details.
-async function showDetailSentTo(sentTo) {
+async function showDetailSentTo(sentTo, activeNetworkId) {
     mockSentTo = sentTo;
     globalThis.document = makeDocument();
     globalThis.window = { location: { search: "" } };
-    state.networkId = "sepolia";
+    state.networkId = activeNetworkId;
     state.blockscoutUrl = "https://explorer.example/api/v2";
     state.viewData = {};
     state.viewStack = [];
@@ -216,21 +216,29 @@ async function showDetailSentTo(sentTo) {
 
 describe("execute() calldata on the transaction detail screen", () => {
     test("sent to a router on the active network, it is a swap", async () => {
-        await showDetailSentTo(SEPOLIA_ROUTER);
+        await showDetailSentTo(SEPOLIA_ROUTER, "sepolia");
+        expect(node("tx-detail-calldata-details").innerHTML).toContain(
+            "Swap via Uniswap Universal Router",
+        );
+    });
+
+    // https://git.eeqj.de/sneak/AutistMask/issues/623
+    test("sent to a router on its network, with the other network active, it is a swap", async () => {
+        await showDetailSentTo(SEPOLIA_ROUTER, "mainnet");
         expect(node("tx-detail-calldata-details").innerHTML).toContain(
             "Swap via Uniswap Universal Router",
         );
     });
 
     test("sent to an ordinary address, it is not decoded", async () => {
-        await showDetailSentTo(ORDINARY);
+        await showDetailSentTo(ORDINARY, "sepolia");
         expect(node("tx-detail-calldata-action").textContent).toBe("execute");
         expect(node("tx-detail-calldata-details").innerHTML).toBe("");
         expect(node("tx-detail-rawdata").innerHTML).toContain(SWAP_DATA);
     });
 
     test("sent to a router of the other network only, it is not decoded", async () => {
-        await showDetailSentTo(MAINNET_ROUTER);
+        await showDetailSentTo(MAINNET_ROUTER, "sepolia");
         expect(node("tx-detail-calldata-action").textContent).toBe("execute");
         expect(node("tx-detail-calldata-details").innerHTML).toBe("");
         expect(node("tx-detail-rawdata").innerHTML).toContain(SWAP_DATA);

tests/walletDefects.test.js

@@ -475,7 +475,7 @@ describe("every way to a signature or the private key refuses a defective wallet
                 to: RECIPIENT,
                 value: "0x0",
                 data: "0x",
-                chainId: 1,
+                chainId: "0x1",
                 nonce: 0,
                 gasLimit: "21000",
                 maxFeePerGas: "1000000000",