fix: a swap's WETH minimum reads as ETH only when all its WETH reaches the UNWRAP_WETH (closes #642)

Between the step that set the output side and the UNWRAP_WETH, only a step the decoder read that is a PERMIT2_PERMIT, a BALANCE_CHECK_ERC20, or a SWEEP, TRANSFER, PAY_PORTION or PAY_PORTION_FULL_PRECISION of a token other than WETH keeps the swap's WETH minimum as an ETH minimum; any other step leaves ETH with no minimum. After an UNWRAP_WETH into the router, any later step but those makes the swap read WETH with no minimum. A WETH fee paid by PAY_PORTION before the UNWRAP_WETH now shows no minimum. README Display Consistency states the same rule. Model: opus-5-5
2026-10-20 16:21:45 +00:00
parent 4472746b89
commit 1146ffd12b
3 changed files with 249 additions and 36 deletions
@@ -11,7 +11,8 @@
 // what each PERMIT2_TRANSFER_FROM moves
 // (https://git.eeqj.de/sneak/AutistMask/issues/611), and when an
 // UNWRAP_WETH makes the output ETH
-// (https://git.eeqj.de/sneak/AutistMask/issues/607).
+// (https://git.eeqj.de/sneak/AutistMask/issues/607 and
+// https://git.eeqj.de/sneak/AutistMask/issues/642).
 //
 // Every swap command, SWEEP, WRAP_ETH, UNWRAP_WETH, TRANSFER, PAY_PORTION,
 // PAY_PORTION_FULL_PRECISION, PERMIT2_TRANSFER_FROM, ACROSS_V4_DEPOSIT_V3 and
@@ -745,6 +746,163 @@ describe("an UNWRAP_WETH makes the output ETH only when the router holds it", ()
    });
 });

+// https://git.eeqj.de/sneak/AutistMask/issues/642: a step between the swap and
+// the UNWRAP_WETH may pay out the router's WETH or add to it, and a step after
+// an UNWRAP_WETH into the router may wrap its ETH and pay it out as WETH. Each
+// read as ETH with the swap's minimum. A step the decoder read that is a
+// PERMIT2_PERMIT, a BALANCE_CHECK_ERC20, or a SWEEP, TRANSFER, PAY_PORTION or
+// PAY_PORTION_FULL_PRECISION of a token other than WETH does neither.
+describe("what reaches the UNWRAP_WETH of the swap's WETH", () => {
+    const NO_MINIMUM_TO_USER = PAID_TO_USER.filter(
+        (l) => l !== "Min. received",
+    );
+    const NO_MINIMUM_ELSEWHERE = PAID_ELSEWHERE.filter(
+        (l) => l !== "Min. paid out",
+    );
+
+    test.each([
+        {
+            kind: "a TRANSFER of 0.0025 WETH",
+            step: transfer(0x05, WETH, OTHER, ONE_WETH / 400n),
+        },
+        {
+            kind: "a PAY_PORTION of 25 bips",
+            step: transfer(0x06, WETH, OTHER, 25n),
+        },
+        {
+            kind: "a PAY_PORTION_FULL_PRECISION of 1e15",
+            step: transfer(0x07, WETH, OTHER, 10n ** 15n),
+        },
+    ])(
+        "$kind to another address between them reads as ETH with no minimum",
+        ({ step }) => {
+            const result = decode(
+                execute(swapToWeth(ADDRESS_THIS), step, unwrapWeth(MSG_SENDER)),
+                USER,
+                ROUTER_V2_1_2,
+            );
+            expect(result.name).toBe("Swap USDT → ETH");
+            expect(labels(result)).toEqual(NO_MINIMUM_ELSEWHERE);
+            expect(paidTo(result)).toEqual([OTHER]);
+        },
+    );
+
+    test.each([
+        {
+            kind: "a SWEEP whose recipient cannot be read",
+            step: withDirtyWord(sweep(WETH, OTHER), 1),
+        },
+        {
+            kind: "a V4 SETTLE of 0.5 WETH from the router",
+            step: v4Swap([
+                0x0b,
+                coder.encode(
+                    ["address", "uint256", "bool"],
+                    [WETH, ONE_WETH / 2n, false],
+                ),
+            ]),
+        },
+        {
+            kind: "a bridge deposit of 0.5 WETH",
+            step: acrossDeposit(USER, USER, WETH, ONE_WETH / 2n),
+        },
+        {
+            kind: "a PERMIT2_TRANSFER_FROM of 0.5 WETH into the router",
+            step: permit2TransferFrom(WETH, ADDRESS_THIS, ONE_WETH / 2n),
+        },
+    ])("$kind between them reads as ETH with no minimum", ({ step }) => {
+        const result = decode(
+            execute(swapToWeth(ADDRESS_THIS), step, unwrapWeth(MSG_SENDER)),
+        );
+        expect(result.name).toBe("Swap USDT → ETH");
+        expect(detail(result, "Min. received")).toBeUndefined();
+        expect(detail(result, "Min. paid out")).toBeUndefined();
+    });
+
+    test.each([
+        {
+            kind: "a PERMIT2_PERMIT between them",
+            steps: [permit2Permit(USDT, USDT_2000), unwrapWeth(MSG_SENDER)],
+        },
+        {
+            kind: "a BALANCE_CHECK_ERC20 between them",
+            steps: [balanceCheck(USDC, 1n, OTHER), unwrapWeth(MSG_SENDER)],
+        },
+        {
+            kind: "a SWEEP of USDC between them",
+            steps: [sweep(USDC, MSG_SENDER), unwrapWeth(MSG_SENDER)],
+        },
+        {
+            kind: "an UNWRAP_WETH into the router, then a SWEEP of its ETH,",
+            steps: [unwrapWeth(ADDRESS_THIS), sweep(ZERO, MSG_SENDER)],
+        },
+    ])("$kind reads as ETH with the swap's minimum", ({ steps }) => {
+        const result = decode(execute(swapToWeth(ADDRESS_THIS), ...steps));
+        expect(result.name).toBe("Swap USDT → ETH");
+        expect(detail(result, "Min. received").value).toBe("1.0000 ETH");
+    });
+
+    // The SWEEP pays the user the swap's WETH, so the UNWRAP_WETH unwraps the
+    // WRAP_ETH's.
+    test("a SWEEP of the swap's WETH to the user, then a WRAP_ETH into the router, reads as ETH with no minimum", () => {
+        const result = decode(
+            execute(
+                swapToWeth(ADDRESS_THIS),
+                sweep(WETH, MSG_SENDER),
+                wrapEth(ADDRESS_THIS, ONE_WETH),
+                unwrapWeth(MSG_SENDER),
+            ),
+        );
+        expect(result.name).toBe("Swap USDT → ETH");
+        expect(labels(result)).toEqual(NO_MINIMUM_TO_USER);
+    });
+
+    test("an UNWRAP_WETH into the router, then a WRAP_ETH of all its ETH to the user, reads as WETH with no minimum", () => {
+        const result = decode(
+            execute(
+                swapToWeth(ADDRESS_THIS),
+                unwrapWeth(ADDRESS_THIS),
+                wrapEth(MSG_SENDER, CONTRACT_BALANCE),
+            ),
+        );
+        expect(result.name).toBe("Swap USDT → WETH");
+        expect(labels(result)).toEqual(NO_MINIMUM_TO_USER);
+    });
+
+    // The user receives 0.5 WETH and the rest of the swap's output as ETH.
+    test("an UNWRAP_WETH into the router, then a WRAP_ETH of 0.5 ETH to the user, reads as WETH with no minimum", () => {
+        const result = decode(
+            execute(
+                swapToWeth(ADDRESS_THIS),
+                unwrapWeth(ADDRESS_THIS),
+                wrapEth(MSG_SENDER, ONE_WETH / 2n),
+                sweep(ZERO, MSG_SENDER),
+            ),
+        );
+        expect(result.name).toBe("Swap USDT → WETH");
+        expect(labels(result)).toEqual(NO_MINIMUM_TO_USER);
+    });
+
+    // The UNWRAP_WETH pays the user the swap's WETH as ETH; the WRAP_ETH wraps
+    // the ETH an earlier V4 step paid the router.
+    test("an UNWRAP_WETH to the user, then a WRAP_ETH of all the router's ETH to the user, reads as ETH", () => {
+        const result = decode(
+            execute(
+                v4Swap(
+                    SWAP_USDT_FOR_ETH,
+                    SETTLE_USDT,
+                    take(ZERO, ADDRESS_THIS),
+                ),
+                swapToWeth(ADDRESS_THIS),
+                unwrapWeth(MSG_SENDER),
+                wrapEth(MSG_SENDER, CONTRACT_BALANCE),
+            ),
+        );
+        expect(detail(result, "Token Out").value).toBe("ETH");
+        expect(detail(result, "Min. received").value).toBe("1.0000 ETH");
+    });
+});
+
 // https://git.eeqj.de/sneak/AutistMask/issues/606: any token a step pays the
 // router stays there unless a later step pays out or spends all of it, not
 // only the swap's output. A V4 SETTLE can take more of the user's tokens than
@@ -1711,15 +1869,6 @@ describe("a payout of part of the router's output", () => {
            ),
            min: "1.0000 WETH",
        },
-        {
-            kind: "PAY_PORTION of 25 bips, then UNWRAP_WETH",
-            data: execute(
-                swapToWeth(ADDRESS_THIS),
-                transfer(0x06, WETH, OTHER, 25n),
-                unwrapWeth(MSG_SENDER),
-            ),
-            min: "1.0000 ETH",
-        },
        {
            kind: "V4 TAKE_PORTION of 25 bips, then TAKE_ALL",
            data: execute(