fix: a V4 swap action not in the deployed shape is shown as not decoded (closes #358)

The four V4 swap actions are read only as the parameter structs deployed
on mainnet and Sepolia. ethers decoded the newer v4-periphery structs,
which add minHopPriceX36, as the deployed ones without an error, and the
newer multi-hop exact-in struct showed the offset of its hop-price array
as the swap amount. A decode now counts only when encoding it again gives
back the same bytes. When a swap action fails that, its step is listed as
"V4 Swap (could not be decoded)", and a token line left without a
currency reads "Unknown (could not be decoded)" rather than "not named in
the calldata". The README records both.

Model: opus-5-5

README.md

@@ -1110,14 +1110,16 @@ read:
 
 The swap's `Token In` and `Token Out` lines name a currency, not an amount; each
 reads `Unknown (not named in the calldata)` when the decoder found no token for
-that side. An `UNWRAP_WETH` step makes `Token Out` ETH only when the output side
-is WETH, on mainnet or Sepolia, or when no step set the output side; a WETH
-`Min. received` figure then reads in ETH. Otherwise `Token Out` and
-`Min. received` keep the output side's own token and figure, whether the swap
-was paid in ETH or in a token: a V2 exact-out swap that buys USDC and then
-unwraps the WETH it did not spend shows USDC. The token permission warning on
-the signature screen has its own amount wording, including `Unknown`; the
-SignApproval section below describes it.
+that side, or `Unknown (could not be decoded)` instead when a V4 swap action in
+the transaction could not be read (see Transaction Decoding below). An
+`UNWRAP_WETH` step makes `Token Out` ETH only when the output side is WETH, on
+mainnet or Sepolia, or when no step set the output side; a WETH `Min. received`
+figure then reads in ETH. Otherwise `Token Out` and `Min. received` keep the
+output side's own token and figure, whether the swap was paid in ETH or in a
+token: a V2 exact-out swap that buys USDC and then unwraps the WETH it did not
+spend shows USDC. The token permission warning on the signature screen has its
+own amount wording, including `Unknown`; the SignApproval section below
+describes it.
 
 The swap's `Deadline` line is the router's deadline as a UTC date and time, e.g.
 `2026-02-27 08:25:51`. A JavaScript date reaches only to 275760-09-13 00:00:00
@@ -2143,12 +2145,7 @@ view would leave a wallet one click from deletion.
       Bytes that are not UTF-8 are shown as "This message is not text." For
       typed data, formatted domain/type/message fields (EIP-712). The primary
       type shown is the one ethers signs, derived from the typed data's `types`,
-      not the type the site states. The message shows only the fields that type
-      declares, at every level of nesting and in the type's order: ethers signs
-      those and drops any other key. Typed data carrying other keys is not
-      refused; each such key is listed after the message under "Not part of the
-      signature", by its place in the message (`details.note`,
-      `details[1].note`) and its value.
+      not the type the site states.
     - Token permission warning, at the top of the message (typed data whose
       primary type is `Permit`, as in EIP-2612, or one of Permit2's signature
       types): "⚠️ TOKEN PERMISSION: Signing this lets the spender below take the
@@ -2695,7 +2692,11 @@ Currently supported:
   or recipient, and amount.
 - **Uniswap Universal Router**: `execute()` calls — shows swap direction (e.g.
   "Swap USDT → ETH"), token addresses, amounts, execution steps, and deadline.
-  Decodes Permit2, V2/V3/V4 swaps, wrap/unwrap, and balance checks.
+  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 any other shape is not read, and its step is listed as
+  `V4 Swap (could not be decoded)`.
 
 ### Non-Goals Forever
 

src/popup/views/approval.js

@@ -626,38 +626,10 @@ function permitWarningHtml(types, primaryType, domain, message) {
     return html;
 }
 
-// What ethers signs of a message value of type `type`: a struct keeps only
-// the fields its type declares, in the type's order, and a list is read item
-// by item. ethers drops every other key, so each one is added to `notSigned`
-// with its place in the message and its value, for the screen to list apart.
-function signedValue(types, type, value, path, notSigned) {
-    const itemType = type.replace(/\[\d*\]$/, "");
-    if (itemType !== type) {
-        if (!Array.isArray(value)) return value;
-        return value.map((item, i) =>
-            signedValue(types, itemType, item, `${path}[${i}]`, notSigned),
-        );
-    }
-    const fields = types[type];
-    if (!fields || !value || typeof value !== "object") return value;
-    const at = (name) => (path ? `${path}.${name}` : name);
-    for (const [key, val] of Object.entries(value)) {
-        if (!fields.some((f) => f.name === key)) notSigned.push([at(key), val]);
-    }
-    return Object.fromEntries(
-        fields.map((f) => [
-            f.name,
-            signedValue(types, f.type, value[f.name], at(f.name), notSigned),
-        ]),
-    );
-}
-
 // The typed data as the screen shows it. The primary type shown is the one
 // ethers signs, never the page's word for it; typedDataRefusal() keeps the two
-// from differing on anything that can be signed. The Message section shows
-// only what is signed, and any other key the page sent is listed after it as
-// not part of the signature. Only typed data that cannot be read at all is
-// shown as raw text, and typedDataRefusal() refuses it.
+// from differing on anything that can be signed. Only typed data that cannot
+// be read at all is shown as raw text, and typedDataRefusal() refuses it.
 function formatTypedDataHtml(jsonStr) {
     let data;
     let primaryType;
@@ -691,30 +663,12 @@ function formatTypedDataHtml(jsonStr) {
     html += `<div class="mb-2"><div class="text-muted">Primary type</div>`;
     html += `<div class="font-bold">${escapeHtml(primaryType)}</div></div>`;
 
-    const lineHtml = (key, val) =>
-        `<div><span class="text-muted">${escapeHtml(key)}:</span> <span class="break-all">${escapeHtml(display(val))}</span></div>`;
-
     if (data.message) {
-        const notSigned = [];
-        const message = signedValue(
-            data.types,
-            primaryType,
-            data.message,
-            "",
-            notSigned,
-        );
         html += `<div class="mb-2"><div class="text-muted">Message</div>`;
-        for (const [key, val] of Object.entries(message)) {
-            html += lineHtml(key, val);
+        for (const [key, val] of Object.entries(data.message)) {
+            html += `<div><span class="text-muted">${escapeHtml(key)}:</span> <span class="break-all">${escapeHtml(display(val))}</span></div>`;
         }
         html += `</div>`;
-        if (notSigned.length > 0) {
-            html += `<div class="mb-2"><div class="text-muted">Not part of the signature</div>`;
-            for (const [key, val] of notSigned) {
-                html += lineHtml(key, val);
-            }
-            html += `</div>`;
-        }
     }
 
     return html;

src/shared/uniswap.js

@@ -53,6 +53,11 @@ function formatAmount(raw, decimals) {
 // on a scale — not as a token name, and not as a quantity.
 const UNNAMED_CURRENCY = "Unknown (not named in the calldata)";
 
+// The same refusal when a V4 swap action could not be read (see
+// decodeExactly()). That action names both of its currencies, so saying the
+// calldata did not name one would be false.
+const UNDECODED_CURRENCY = "Unknown (could not be decoded)";
+
 // Explicit presence, never truthiness. Every gate in this file that guards a
 // decoded value goes through here: an address is never falsy once set, but an
 // amount of 0n is, and a gate that cannot tell a genuine zero from an absent
@@ -295,6 +300,24 @@ function v4ExactInAmount(raw) {
     return raw === 0n ? OPEN_DELTA : raw;
 }
 
+// The V4 swap actions are read only in the parameter structs V4Router has
+// deployed on mainnet and Sepolia. v4-periphery `main` has since added a
+// `minHopPriceX36` field to all four (`src/interfaces/IV4Router.sol`), and
+// reading a shape nobody has deployed would be guessing. ethers alone would
+// read the newer structs anyway: it takes whatever word sits where a
+// deployed field would be, ignores bytes left over, and holds back an error
+// in a field until that field is used. The newer multi-hop exact-in struct
+// then yields the offset of its hop-price array as `amountIn`. So a decode
+// counts only when encoding the result again gives back the same bytes;
+// otherwise this throws, and decodeV4Swap() marks the step as not decoded.
+function decodeExactly(types, data) {
+    const decoded = coder.decode(types, data);
+    if (coder.encode(types, decoded) !== data) {
+        throw new Error("Not in the deployed V4 parameter shape.");
+    }
+    return decoded;
+}
+
 // Decode V4_SWAP (command 0x10) input bytes.
 // The input is ABI-encoded as (bytes actions, bytes[] params).
 // We extract token addresses from SETTLE (input) and TAKE (output) sub-actions,
@@ -309,6 +332,10 @@ function decodeV4Swap(input) {
         let takeToken = null;
         let amountIn = null;
         let amountOutMin = null;
+        // Set when a swap action's parameters are not in the deployed shape
+        // (see decodeExactly()), so nothing was read from that action. SETTLE
+        // and TAKE may still name both currencies.
+        let swapUndecoded = false;
 
         for (let i = 0; i < actions.length; i++) {
             const actionId = actions[i];
@@ -337,7 +364,7 @@ function decodeV4Swap(input) {
                         //   tuple(address,uint24,int24,address,bytes)[] path,
                         //   uint128 amountIn, uint128 amountOutMin)
                         try {
-                            const s = coder.decode(
+                            const s = decodeExactly(
                                 [
                                     "tuple(address,tuple(address,uint24,int24,address,bytes)[],uint128,uint128)",
                                 ],
@@ -355,13 +382,13 @@ function decodeV4Swap(input) {
                                 amountOutMin = s[0][3];
                             }
                         } catch {
-                            // Fall through — SETTLE/TAKE will provide tokens
+                            swapUndecoded = true;
                         }
                     } else {
                         // ExactInputSingleParams: (tuple(address,address,uint24,int24,address) poolKey,
                         //   bool zeroForOne, uint128 amountIn, uint128 amountOutMin, bytes hookData)
                         try {
-                            const s = coder.decode(
+                            const s = decodeExactly(
                                 [
                                     "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
                                 ],
@@ -384,7 +411,7 @@ function decodeV4Swap(input) {
                                 amountOutMin = s[0][3];
                             }
                         } catch {
-                            // Fall through
+                            swapUndecoded = true;
                         }
                     }
                 } else if (
@@ -393,7 +420,7 @@ function decodeV4Swap(input) {
                 ) {
                     if (actionId === V4_SWAP_EXACT_OUT) {
                         try {
-                            const s = coder.decode(
+                            const s = decodeExactly(
                                 [
                                     "tuple(address,tuple(address,uint24,int24,address,bytes)[],uint128,uint128)",
                                 ],
@@ -405,11 +432,11 @@ function decodeV4Swap(input) {
                                 settleToken = path[path.length - 1][0];
                             }
                         } catch {
-                            // Fall through
+                            swapUndecoded = true;
                         }
                     } else {
                         try {
-                            const s = coder.decode(
+                            const s = decodeExactly(
                                 [
                                     "tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)",
                                 ],
@@ -426,7 +453,7 @@ function decodeV4Swap(input) {
                                     ? poolKey[1]
                                     : poolKey[0];
                         } catch {
-                            // Fall through
+                            swapUndecoded = true;
                         }
                     }
                 }
@@ -440,6 +467,7 @@ function decodeV4Swap(input) {
             tokenOut: takeToken,
             amountIn,
             amountOutMin,
+            swapUndecoded,
         };
     } catch {
         return null;
@@ -465,6 +493,7 @@ function decode(data, toAddress, sources) {
         let minOutput = null;
         let hasUnwrapWeth = false;
         let hasV2ExactOut = false;
+        let swapUndecoded = false;
         const commandNames = [];
 
         // THE INVARIANT: an amount and the token it is counted in always come
@@ -568,6 +597,12 @@ function decode(data, toAddress, sources) {
                 if (cmdId === 0x10) {
                     const v4 = decodeV4Swap(inputs[i]);
                     if (v4) {
+                        // Without this, a swap action that went unread would
+                        // look like one that had nothing to show.
+                        if (v4.swapUndecoded) {
+                            swapUndecoded = true;
+                            commandNames[i] += " (could not be decoded)";
+                        }
                         setInputOnce(v4.tokenIn, v4.amountIn);
                         // Always update output: last swap step wins. A step
                         // that carries the Min. received figure but decoded no
@@ -591,12 +626,13 @@ 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 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.
+        // Resolve token info. A null token on either side means no step that
+        // was read named a currency for it; tokenInfo() refuses rather than
+        // calling it 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());
@@ -640,7 +676,10 @@ function decode(data, toAddress, sources) {
             // rather than going missing or naming a token by default. Same
             // wording as the Token Out refusal below: the two sides of this
             // screen must not describe the same condition in two ways.
-            details.push({ label: "Token In", value: UNNAMED_CURRENCY });
+            details.push({
+                label: "Token In",
+                value: swapUndecoded ? UNDECODED_CURRENCY : UNNAMED_CURRENCY,
+            });
         }
 
         if (present(inputAmount)) {
@@ -703,7 +742,10 @@ function decode(data, toAddress, sources) {
             // rather than going missing or naming a token by default, and a
             // Min. received figure below it is never attached to a token the
             // calldata did not state.
-            details.push({ label: "Token Out", value: UNNAMED_CURRENCY });
+            details.push({
+                label: "Token Out",
+                value: swapUndecoded ? UNDECODED_CURRENCY : UNNAMED_CURRENCY,
+            });
         }
 
         if (present(minOutput)) {

src/shared/walletDefects.js

@@ -36,13 +36,11 @@ const DEFECTS = {
                 "derivation path beneath that key instead of from a master " +
                 "key, so the addresses listed here are not the ones that key " +
                 "produces under the standard path.",
-            "Signing, sending and private key export are disabled for this " +
-                "wallet. Anything these addresses hold can be reached outside " +
-                "this wallet with the extended private key you imported, if " +
-                "you kept a copy of it, or with the master extended private " +
-                "key or recovery phrase it came from, in software that " +
-                "repeats the same non-standard derivation. Check the " +
-                "addresses in a block explorer before deciding what to do.",
+            "Signing and sending are disabled for this wallet. The addresses " +
+                "do descend from the extended private key you imported, so " +
+                "anything they hold is still reachable by software that " +
+                "repeats the same non-standard derivation. Check them in a " +
+                "block explorer before deciding what to do.",
             "To see the addresses this key produces under the standard path, " +
                 "import the master extended private key, or the recovery " +
                 "phrase it came from, as a new wallet. Nothing here has been " +

tests/typedDataPermit.test.js

@@ -233,26 +233,6 @@ function warningOf(data) {
     return html.slice(0, html.indexOf(">Domain<"));
 }
 
-const NOT_SIGNED = ">Not part of the signature<";
-
-// The Message section alone, without the keys listed after it as not part of
-// the signature.
-function messageOf(data) {
-    const html = formatTypedDataHtml(JSON.stringify(data));
-    const end = html.indexOf(NOT_SIGNED);
-    return html.slice(
-        html.indexOf(">Message<"),
-        end === -1 ? html.length : end,
-    );
-}
-
-// The keys listed as not part of the signature, or "" when there are none.
-function notSignedOf(data) {
-    const html = formatTypedDataHtml(JSON.stringify(data));
-    const start = html.indexOf(NOT_SIGNED);
-    return start === -1 ? "" : html.slice(start);
-}
-
 function request(data) {
     return { method: "eth_signTypedData_v4", typedData: JSON.stringify(data) };
 }
@@ -332,8 +312,7 @@ describe("the warning reads only the fields the signed type declares", () => {
     });
 
     // A Permit whose type names its spender `operator`; the page adds a
-    // `spender` key the type does not declare. The Message section names
-    // only the operator, and the added key is listed apart as not signed.
+    // `spender` key the type does not declare.
     test("an added key is not named as the spender", () => {
         const data = {
             ...PERMIT,
@@ -352,10 +331,6 @@ describe("the warning reads only the fields the signed type declares", () => {
         const warning = warningOf(data);
         expect(warning).toContain(WARNING);
         expect(warning).not.toContain(DECOY);
-        expect(messageOf(data)).toContain(SPENDER);
-        expect(messageOf(data)).not.toContain(DECOY);
-        expect(notSignedOf(data)).toContain("spender:");
-        expect(notSignedOf(data)).toContain(DECOY);
     });
 
     // The permit for a Uniswap v3 position NFT: a `Permit` with no amount
@@ -396,47 +371,6 @@ describe("the warning reads only the fields the signed type declares", () => {
     });
 });
 
-// ethers signs only the declared fields at every level of nesting, so an
-// added key inside a struct is not signed either. Such typed data is not
-// refused; the added key is listed apart, with where it sits in the message.
-describe("the Message section shows only the fields that are signed", () => {
-    const NOTE = "This signature only signs you in";
-
-    test("an added key inside a nested struct is listed as not signed", () => {
-        const data = {
-            ...PERMIT_SINGLE,
-            message: {
-                ...PERMIT_SINGLE.message,
-                details: { ...PERMIT_SINGLE.message.details, note: NOTE },
-            },
-        };
-        expect(messageOf(data)).toContain("expiration");
-        expect(messageOf(data)).not.toContain(NOTE);
-        expect(notSignedOf(data)).toContain("details.note:");
-        expect(notSignedOf(data)).toContain(NOTE);
-        expect(typedDataRefusal(request(data))).toBeNull();
-    });
-
-    test("an added key inside a list item is listed with its index", () => {
-        const [first, second] = PERMIT_BATCH.message.details;
-        const data = {
-            ...PERMIT_BATCH,
-            message: {
-                ...PERMIT_BATCH.message,
-                details: [first, { ...second, note: NOTE }],
-            },
-        };
-        expect(messageOf(data)).not.toContain(NOTE);
-        expect(notSignedOf(data)).toContain("details[1].note:");
-        expect(notSignedOf(data)).toContain(NOTE);
-    });
-
-    test("nothing is listed apart when every key is declared", () => {
-        expect(notSignedOf(PERMIT_SINGLE)).toBe("");
-        expect(notSignedOf(LOGIN)).toBe("");
-    });
-});
-
 describe("the primary type shown is the one ethers signs", () => {
     // A drain stated as a sign-in: the page says Login, the types say
     // PermitSingle, and ethers would sign PermitSingle.

tests/uniswap.test.js

@@ -163,6 +163,110 @@ function encodeV4ExactInSingle(currency0, currency1, amountIn, amountOutMin) {
     );
 }
 
+// Each V4 swap action's parameters in two shapes: the struct V4Router has
+// deployed on mainnet and Sepolia, and the one v4-periphery `main` has since
+// moved to, which adds a `minHopPriceX36` field. Each swaps WETH for USDC.
+const POOL_KEY = "tuple(address,address,uint24,int24,address)";
+const PATH_KEY = "tuple(address,uint24,int24,address,bytes)";
+const WETH_USDC_POOL = [WETH_ADDR, USDC_ADDR, 100, 1, ZERO_ADDR];
+const ONE_WETH = 1000000000000000000n;
+const V4_SWAP_ACTION_SHAPES = [
+    {
+        action: "SWAP_EXACT_IN_SINGLE",
+        id: 0x06,
+        deployed: coder.encode(
+            [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
+            [[WETH_USDC_POOL, true, ONE_WETH, 990000n, "0x"]],
+        ),
+        newer: coder.encode(
+            [`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
+            [[WETH_USDC_POOL, true, ONE_WETH, 990000n, 0n, "0x"]],
+        ),
+    },
+    {
+        action: "SWAP_EXACT_IN",
+        id: 0x07,
+        deployed: coder.encode(
+            [`tuple(address,${PATH_KEY}[],uint128,uint128)`],
+            [
+                [
+                    WETH_ADDR,
+                    [[USDC_ADDR, 100, 1, ZERO_ADDR, "0x"]],
+                    ONE_WETH,
+                    990000n,
+                ],
+            ],
+        ),
+        newer: coder.encode(
+            [`tuple(address,${PATH_KEY}[],uint256[],uint128,uint128)`],
+            [
+                [
+                    WETH_ADDR,
+                    [[USDC_ADDR, 100, 1, ZERO_ADDR, "0x"]],
+                    [],
+                    ONE_WETH,
+                    990000n,
+                ],
+            ],
+        ),
+    },
+    {
+        action: "SWAP_EXACT_OUT_SINGLE",
+        id: 0x08,
+        deployed: coder.encode(
+            [`tuple(${POOL_KEY},bool,uint128,uint128,bytes)`],
+            [[WETH_USDC_POOL, true, 990000n, ONE_WETH, "0x"]],
+        ),
+        newer: coder.encode(
+            [`tuple(${POOL_KEY},bool,uint128,uint128,uint256,bytes)`],
+            [[WETH_USDC_POOL, true, 990000n, ONE_WETH, 0n, "0x"]],
+        ),
+    },
+    {
+        action: "SWAP_EXACT_OUT",
+        id: 0x09,
+        deployed: coder.encode(
+            [`tuple(address,${PATH_KEY}[],uint128,uint128)`],
+            [
+                [
+                    USDC_ADDR,
+                    [[WETH_ADDR, 100, 1, ZERO_ADDR, "0x"]],
+                    990000n,
+                    ONE_WETH,
+                ],
+            ],
+        ),
+        newer: coder.encode(
+            [`tuple(address,${PATH_KEY}[],uint256[],uint128,uint128)`],
+            [
+                [
+                    USDC_ADDR,
+                    [[WETH_ADDR, 100, 1, ZERO_ADDR, "0x"]],
+                    [],
+                    990000n,
+                    ONE_WETH,
+                ],
+            ],
+        ),
+    },
+];
+
+// Helper: execute() with one V4_SWAP step holding the swap action, then
+// SETTLE of WETH and TAKE of USDC.
+function v4SwapCalldata(actionId, swapParams) {
+    return buildExecute(
+        "0x10",
+        [
+            encodeV4Swap(new Uint8Array([actionId, V4_SETTLE_ID, V4_TAKE_ID]), [
+                swapParams,
+                encodeV4Settle(WETH_ADDR),
+                encodeV4Take(USDC_ADDR),
+            ]),
+        ],
+        9999999999n,
+    );
+}
+
 function detail(result, label) {
     return result.details.find((d) => d.label === label);
 }
@@ -203,11 +307,83 @@ describe("uniswap decoder", () => {
             result.details.find((d) => d.label === "Min. received").value,
         ).toBe("0.0002 ETH");
 
+        // Real mainnet calldata is in the deployed shape, so its V4 step is
+        // not said to be undecoded.
         const steps = result.details.find((d) => d.label === "Steps");
-        expect(steps.value).toContain("Permit2 Permit");
-        expect(steps.value).toContain("V4 Swap");
+        expect(steps.value).toBe("Permit2 Permit → V4 Swap");
     });
 
+    test.each(V4_SWAP_ACTION_SHAPES)(
+        "a V4 $action in the deployed shape is read",
+        ({ id, deployed }) => {
+            const result = uniswap.decode(
+                v4SwapCalldata(id, deployed),
+                ROUTER_ADDR,
+            );
+            expect(detail(result, "Steps").value).toBe("V4 Swap");
+        },
+    );
+
+    // https://git.eeqj.de/sneak/AutistMask/issues/358 — before it, all four
+    // newer structs decoded as the deployed ones without an error, and the
+    // newer SWAP_EXACT_IN showed the offset of its hop-price array as Amount
+    // ("0.0000000000000004 WETH") and its amountIn as Min. received.
+    test.each(V4_SWAP_ACTION_SHAPES)(
+        "a V4 $action in the newer periphery shape is shown as not decoded",
+        ({ id, newer }) => {
+            const result = uniswap.decode(
+                v4SwapCalldata(id, newer),
+                ROUTER_ADDR,
+            );
+            expect(detail(result, "Amount")).toBeUndefined();
+            expect(detail(result, "Min. received")).toBeUndefined();
+            expect(detail(result, "Steps").value).toBe(
+                "V4 Swap (could not be decoded)",
+            );
+            // SETTLE and TAKE keep their own shape and still name both sides.
+            expect(detail(result, "Token In").address).toBe(WETH_ADDR);
+            expect(detail(result, "Token Out").address).toBe(USDC_ADDR);
+        },
+    );
+
+    // The decoder does not read SETTLE_ALL or TAKE_ALL, so here only the
+    // unread swap action names the currencies. The token lines must not say
+    // the calldata did not name them.
+    test.each(V4_SWAP_ACTION_SHAPES)(
+        "a V4 $action in the newer shape, then SETTLE_ALL and TAKE_ALL, says both tokens could not be decoded",
+        ({ id, newer }) => {
+            const data = buildExecute(
+                "0x10",
+                [
+                    // 0x0c is SETTLE_ALL (currency, maxAmount), 0x0f is
+                    // TAKE_ALL (currency, minAmount).
+                    encodeV4Swap(new Uint8Array([id, 0x0c, 0x0f]), [
+                        newer,
+                        coder.encode(
+                            ["address", "uint256"],
+                            [WETH_ADDR, ONE_WETH],
+                        ),
+                        coder.encode(
+                            ["address", "uint256"],
+                            [USDC_ADDR, 990000n],
+                        ),
+                    ]),
+                ],
+                9999999999n,
+            );
+            const result = uniswap.decode(data, ROUTER_ADDR);
+            expect(detail(result, "Steps").value).toBe(
+                "V4 Swap (could not be decoded)",
+            );
+            expect(detail(result, "Token In").value).toBe(
+                "Unknown (could not be decoded)",
+            );
+            expect(detail(result, "Token Out").value).toBe(
+                "Unknown (could not be decoded)",
+            );
+        },
+    );
+
     test("decodes V2_SWAP_EXACT_IN with known tokens", () => {
         const data = buildExecute(
             "0x08", // V2_SWAP_EXACT_IN
@@ -548,9 +724,11 @@ describe("uniswap decoder", () => {
         const result = uniswap.decode(data, ROUTER_ADDR);
         expect(result).not.toBeNull();
 
+        // The V4 swap action's parameters are empty, so that step is said to
+        // be undecoded.
         const steps = result.details.find((d) => d.label === "Steps");
         expect(steps.value).toBe(
-            "Permit2 Permit \u2192 V4 Swap \u2192 Unwrap WETH",
+            "Permit2 Permit \u2192 V4 Swap (could not be decoded) \u2192 Unwrap WETH",
         );
     });
 

tests/uniswapUndeterminedTokenIn.test.js

@@ -97,7 +97,11 @@ describe("an execute() whose input currency never decoded", () => {
         ]);
 
     test("says the input token is unknown instead of naming ETH", () => {
-        expect(detail(data(), "Token In").value).toBe(REFUSAL);
+        // The swap action that would name it could not be read, so the line
+        // says that rather than REFUSAL's "not named in the calldata".
+        expect(detail(data(), "Token In").value).toBe(
+            "Unknown (could not be decoded)",
+        );
     });
 
     test("keeps a Token In line, so the screen never omits what is paid", () => {

tests/walletDefects.test.js

@@ -153,18 +153,6 @@ describe("the explanatory copy", () => {
         expect(all).not.toMatch(/\blost\b|\bstolen\b|\bgone\b/i);
     });
 
-    // The wallet holds the imported key but will not export it, so the copy
-    // must name every key the user may hold that reaches the addresses
-    // outside it.
-    test("it names the keys that reach the addresses outside this wallet", () => {
-        const body = defect.paragraphs.join(" ");
-
-        expect(body).toMatch(/private key export are disabled/);
-        expect(body).toMatch(
-            /with the extended private key you imported, if you kept a copy of it, or with the master extended private key or recovery phrase it came from, in software that repeats the same non-standard derivation/,
-        );
-    });
-
     test("it says the wallet is not deleted and what the user can do", () => {
         const body = defect.paragraphs.join(" ");