fix: decode Uniswap V2 exact-out swaps, input amount shown as a maximum (closes #283)

decode() had no arm for Universal Router command 0x09, so the approval
screen showed no token or amount for it. It now takes the path's first
token and amountInMax as the input side, the last token and amountOut as
the output side. With such a step, the Amount figure reads "Up to
<amount>" whichever step set it, on the approval, wait, success and error
screens, unless it reads "Unlimited", as an unbounded PERMIT2_PERMIT does,
or "All available (V4 open delta)". In every swap, UNWRAP_WETH makes
Token Out ETH only when the output side is WETH, on mainnet or Sepolia, or
no step set it; otherwise the output keeps its own token and figure.
decodeV2SwapExactOut() loses its eslint-disable comment.

Model: opus-5-5

src/shared/uniswap.js

@@ -100,6 +100,13 @@ const NO_MINIMUM = "None (no minimum guaranteed)";
 // Permit2 amounts are uint160; the maximum is Permit2's "unbounded".
 const MAX_UINT160 = BigInt("0xffffffffffffffffffffffffffffffffffffffff");
 
+// WETH, the token UNWRAP_WETH turns into ETH: on mainnet, then on Sepolia.
+// decode() is not told the network, so it takes either.
+const WETH_ADDRESSES = [
+    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+    "0xfff9976782d46cc05630d1f6ebab18b2324d6b14",
+];
+
 // `decimals` is null when nothing knows this token's scale. It is not
 // defaulted to 18: the swap lines land on the same approval screen as the
 // ERC-20 line, and a scale guessed there is what showed a 1,000 USDT swap as
@@ -198,11 +205,6 @@ function decodeV2SwapExactIn(input) {
 // Decode V2_SWAP_EXACT_OUT (command 0x09) input bytes.
 // ABI: (address recipient, uint256 amountOut, uint256 amountInMax,
 //        address[] path, bool payerIsUser)
-//
-// Nothing calls this: decode() has no 0x09 arm, so a V2 exact-out swap gets
-// its command name and no token or amount detail. Kept for the fix, which is
-// https://git.eeqj.de/sneak/AutistMask/issues/283.
-// eslint-disable-next-line no-unused-vars
 function decodeV2SwapExactOut(input) {
     try {
         const d = coder.decode(
@@ -447,6 +449,7 @@ function decode(data, toAddress, sources) {
         let outputToken = null;
         let minOutput = null;
         let hasUnwrapWeth = false;
+        let hasV2ExactOut = false;
         const commandNames = [];
 
         // THE INVARIANT: an amount and the token it is counted in always come
@@ -521,6 +524,16 @@ function decode(data, toAddress, sources) {
                     }
                 }
 
+                if (cmdId === 0x09) {
+                    // Buys exactly amountOut and spends at most amountInMax.
+                    hasV2ExactOut = true;
+                    const s = decodeV2SwapExactOut(inputs[i]);
+                    if (s) {
+                        setInputOnce(s.tokenIn, s.amountInMax);
+                        setOutput(s.tokenOut, s.amountOut);
+                    }
+                }
+
                 if (cmdId === 0x0b) {
                     const w = decodeWrapEth(inputs[i]);
                     if (w) {
@@ -559,12 +572,19 @@ function decode(data, toAddress, sources) {
 
         // Resolve token info. A null token on either side means the calldata
         // named no currency for it; tokenInfo() refuses rather than calling it
-        // ETH. UNWRAP_WETH is the one output that is ETH without a currency to
-        // decode, and it is answered here rather than left to that rule.
+        // ETH. UNWRAP_WETH turns WETH into ETH, so it makes the output ETH
+        // when the output side is WETH, or when no step set the output side.
+        // Any other output keeps its own token and figure: a swap that buys
+        // USDC and then unwraps the WETH it did not spend receives USDC.
+        const outputIsWeth =
+            present(outputToken) &&
+            WETH_ADDRESSES.includes(outputToken.toLowerCase());
+        const outputUnset = !present(outputToken) && !present(minOutput);
         const inInfo = tokenInfo(inputToken, sources);
-        const outInfo = hasUnwrapWeth
-            ? { symbol: "ETH", decimals: 18, address: null }
-            : tokenInfo(outputToken, sources);
+        const outInfo =
+            hasUnwrapWeth && (outputIsWeth || outputUnset)
+                ? { symbol: "ETH", decimals: 18, address: null }
+                : tokenInfo(outputToken, sources);
 
         const inSymbol = inInfo.symbol;
         const outSymbol = outInfo.symbol;
@@ -613,6 +633,17 @@ function decode(data, toAddress, sources) {
                 amount = { raw: OPEN_DELTA_AMOUNT, display: OPEN_DELTA_AMOUNT };
             } else if (inputAmount >= MAX_UINT160) {
                 amount = { raw: "Unlimited", display: "Unlimited" };
+            } else 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 = {
+                    raw: "Up to " + most.raw,
+                    display: "Up to " + most.display,
+                };
             } else {
                 amount = amountText(inputAmount, inInfo);
             }