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
2026-10-14 09:03:49 +00:00
9 changed files with 282 additions and 175 deletions
@@ -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
@@ -2075,11 +2077,7 @@ view would leave a wallet one click from deletion.
  artifact can be compared with it field for field. A nonce the site supplies is
  ignored: the nonce is always the account's next nonce from the node, so a site
  cannot replace one of the user's pending transactions or leave this one stuck
-  behind a gap. A gas limit the site supplies, as `gas` or `gasLimit`, is the
-  one shown and signed in place of the node's estimate, but the node still
-  estimates the transaction with that limit, as the check that it neither
-  reverts nor runs out of gas; a request that gives both with different values
-  is refused. A request that cannot be populated — unreachable node, reverting
+  behind a gap. A request that cannot be populated — unreachable node, reverting
  gas estimate — opens no window and is failed back to the site. Only one
  transaction approval exists at a time: populating fixes the nonce, so a second
  `eth_sendTransaction` arriving while one is unanswered is refused with
@@ -2694,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

@@ -1,14 +1,13 @@
 // Preparation of the transaction an approval screen displays.
 //
-// A dApp's eth_sendTransaction normally fixes `to`, `value` and `data`, and
-// sometimes the gas limit. The nonce, the fees, and the gas limit when the
-// site gives none have to be filled in from the network before anything can
-// be signed, and whoever fills them in decides what the user is shown. That
-// work used to happen in the popup, after the user had already approved: the
-// numbers on the approval screen came from the popup and were compared against
-// nothing, so a compromised popup could display one fee and sign another, and
-// the ceilings in approvalVerify.js were all that stood between the user and a
-// fee that hands the validator the balance.
+// A dApp's eth_sendTransaction normally fixes only `to`, `value` and `data`.
+// The nonce, the gas limit and the fees have to be filled in from the network
+// before anything can be signed, and whoever fills them in decides what the
+// user is shown. That work used to happen in the popup, after the user had
+// already approved: the numbers on the approval screen came from the popup and
+// were compared against nothing, so a compromised popup could display one fee
+// and sign another, and the ceilings in approvalVerify.js were all that stood
+// between the user and a fee that hands the validator the balance.
 //
 // So it happens here instead, in the background, before the approval window is
 // opened. The background populates the transaction, shows that object, and
@@ -32,7 +31,6 @@ const {
    VoidSigner,
    accessListify,
    getAddress,
-    getBigInt,
    getBytes,
    hexlify,
    toQuantity,
@@ -49,11 +47,10 @@ const {
 // minutes long, which is not a wait anyone will sit through.
 const POPULATE_TIMEOUT_MS = 20000;

-// The request fields taken from the page, plus `gas`, which requestFrom()
-// takes as the gas limit. Anything else is dropped rather than passed to
-// ethers: the object is page-controlled, and a future ethers that learns to
-// carry a new transaction field must not start picking one up out of it
-// without this module knowing.
+// The request fields taken from the page. Anything else is dropped rather than
+// passed to ethers: the object is page-controlled, and a future ethers that
+// learns to carry a new transaction field must not start picking one up out of
+// it without this module knowing.
 //
 // The nonce is not taken from the page; it is always the account's next nonce
 // from the network. A page that chose it could replace one of the user's
@@ -87,16 +84,6 @@ function present(v) {
    return v !== null && v !== undefined && v !== "";
 }

-// Whether two quantities from the page are the same number. One that is not a
-// number matches nothing.
-function sameQuantity(a, b) {
-    try {
-        return getBigInt(a) === getBigInt(b);
-    } catch {
-        return false;
-    }
-}
-
 // These strings reach the user through the requesting page, so they are full
 // sentences even when the tail of one came from ethers or from the node.
 function sentence(text) {
@@ -124,20 +111,6 @@ function requestFrom(txParams, from) {
    for (const key of REQUEST_FIELDS) {
        if (present(txParams[key])) request[key] = txParams[key];
    }
-    // JSON-RPC calls the gas limit `gas`, and that is the name sites send.
-    // ethers only reads `gasLimit`: left as `gas` it would be dropped and an
-    // estimate signed in its place.
-    if (present(txParams.gas)) {
-        if (
-            present(request.gasLimit) &&
-            !sameQuantity(request.gasLimit, txParams.gas)
-        ) {
-            throw fail(
-                "The site asked for two different gas limits for this transaction.",
-            );
-        }
-        request.gasLimit = txParams.gas;
-    }
    if (
        present(request.type) &&
        !ALLOWED_TX_TYPES.includes(Number(request.type))
@@ -201,7 +174,6 @@ async function prepareApprovalTx(provider, from, txParams) {
        throw fail("There is no active address to send this transaction from.");
    }
    const request = requestFrom(txParams || {}, from);
-    const signer = new VoidSigner(getAddress(from), provider);

    let populated;
    try {
@@ -209,20 +181,10 @@ async function prepareApprovalTx(provider, from, txParams) {
        // nonce, gas, fee and chain id are populated exactly as they were when
        // the popup did this. VoidSigner cannot sign, which is the point: the
        // background prepares, the popup signs.
-        //
-        // ethers asks the node for a gas estimate only when the request has
-        // no gas limit, and that estimate is the only check that the
-        // transaction does not revert. So a request carrying the site's gas
-        // limit is estimated first, with that limit: one that reverts, or
-        // needs more gas than the site gave it, fails here as well. The
-        // site's gas limit is still the one populated.
        populated = await withTimeout(
-            (async () => {
-                if (present(request.gasLimit)) {
-                    await signer.estimateGas(request);
-                }
-                return signer.populateTransaction(request);
-            })(),
+            new VoidSigner(getAddress(from), provider).populateTransaction(
+                request,
+            ),
            POPULATE_TIMEOUT_MS,
            "The transaction could not be prepared: the network did not answer in time.",
        );
@@ -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)) {
@@ -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 " +
@@ -9,7 +9,7 @@
 // requesting page or the RPC node can say turns it into an approval that
 // should never have been raised.

-const { Network, Transaction, Wallet, toQuantity } = require("ethers");
+const { Network, Wallet } = require("ethers");
 const {
    prepareApprovalTx,
    serializeApprovedTx,
@@ -138,49 +138,6 @@ describe("prepareApprovalTx", () => {
        expect(approved.maxFeePerGas).toBe("0x12a05f200");
    });

-    // `gas` is the JSON-RPC name for the gas limit and the one sites send.
-    // The node is still asked for its estimate, with the site's gas limit,
-    // because the estimate is the check that the transaction does not revert.
-    // It estimates 21000; the site's 200000 is what is shown and what is
-    // signed.
-    test("uses the gas limit a site sends as gas", async () => {
-        const estimateGas = jest.fn(async () => 21000n);
-        const approved = await prepareApprovalTx(
-            providerWith({ estimateGas }),
-            signer.address,
-            { ...TX_PARAMS, gas: "0x30d40" },
-        );
-        expect(estimateGas).toHaveBeenCalledWith(
-            expect.objectContaining({ gasLimit: 200000n }),
-        );
-        expect(approved.gasLimit).toBe("0x30d40");
-        const signed = Transaction.from(
-            await signer.signTransaction({ ...approved }),
-        );
-        expect(signed.gasLimit).toBe(200000n);
-    });
-
-    test("accepts gas and gasLimit that name the same number", async () => {
-        const approved = await prepareApprovalTx(
-            providerWith(),
-            signer.address,
-            { ...TX_PARAMS, gas: "0x30d40", gasLimit: 200000 },
-        );
-        expect(approved.gasLimit).toBe("0x30d40");
-    });
-
-    test("refuses gas and gasLimit that disagree", async () => {
-        await expect(
-            prepareApprovalTx(providerWith(), signer.address, {
-                ...TX_PARAMS,
-                gas: "0x30d40",
-                gasLimit: "0x5208",
-            }),
-        ).rejects.toThrow(
-            "The site asked for two different gas limits for this transaction.",
-        );
-    });
-
    test("carries an access list the request asked for", async () => {
        const approved = await prepareApprovalTx(
            providerWith(),
@@ -255,15 +212,6 @@ describe("prepareApprovalTx", () => {
        ).rejects.toThrow(/gas limit no network this wallet supports/);
    });

-    test("refuses a gas limit the site sent above the ceiling", async () => {
-        await expect(
-            prepareApprovalTx(providerWith(), signer.address, {
-                ...TX_PARAMS,
-                gas: toQuantity(MAX_GAS_LIMIT + 1n),
-            }),
-        ).rejects.toThrow(/gas limit no network this wallet supports/);
-    });
-
    // The combined bound at population: a gas limit and a fee that are each
    // under their own ceiling but multiply to thousands of ETH is refused
    // before the approval window opens, so the user is never shown a
@@ -303,22 +251,6 @@ describe("prepareApprovalTx", () => {
        expect(thrown.message).toMatch(/^[A-Z].*\.$/);
    });

-    test("fails back a reverting request that sends its own gas limit", async () => {
-        const reverting = providerWith({
-            estimateGas: async () => {
-                throw new Error("execution reverted: ERC20: transfer amount");
-            },
-        });
-        await expect(
-            prepareApprovalTx(reverting, signer.address, {
-                ...TX_PARAMS,
-                gas: "0x30d40",
-            }),
-        ).rejects.toThrow(
-            /^The transaction could not be prepared: execution reverted/,
-        );
-    });
-
    // Without a bound, an unreachable node leaves the page's promise pending
    // with nothing on screen to explain it.
    test("gives up on a node that never answers", async () => {
@@ -58,6 +58,7 @@ const TX_PARAMS = {
    to: RECIPIENT,
    value: "0x2386f26fc10000",
    data: "0xdeadbeef",
+    gas: "0x5208",
 };

 // The values populateTransaction() fills in when the dApp fixed none of them.
@@ -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",
        );
    });

@@ -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", () => {
@@ -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(" ");