fix: the swap decoder names where a WRAP_ETH pays and counts the router's ETH in a V4 settle (closes #665)

A WRAP_ETH that sets the input side and pays its WETH to anyone but
the router now names that recipient on its Moved to line, or reads
The sender for address(1).

V4Router pays ETH from the router's own ETH, whoever a SETTLE names as
payer. ETH the router already holds now pays first for the ETH a V4
step would take from the user, and only the rest is moved from the
sender. An UNWRAP_WETH into the router keeps a known WETH amount as
the ETH the router then holds.

Model: opus-5-5

tests/uniswap.test.js

@@ -2424,6 +2424,113 @@ describe("uniswap decoder", () => {
             expect(linesBetweenTokens(result)).toEqual(lines);
         });
 
+        // https://git.eeqj.de/sneak/AutistMask/issues/665 — a WRAP_ETH that
+        // sets the input side and pays its WETH to anyone but the router
+        // names that recipient on its Moved to line. On next each row read
+        // The swap step that spends it.
+        const ONE_ETH = 1000000000000000000n;
+        const MSG_SENDER = "0x0000000000000000000000000000000000000001";
+        // The lines of a WRAP_ETH of 1 ETH whose Moved to line reads `to`.
+        const wrapLines = (to) => [
+            ["Moved from the sender", "1.0000 ETH"],
+            ["Token moved", "ETH"],
+            ["Moved to", to],
+        ];
+        test.each([
+            {
+                kind: "a WRAP_ETH of 1 ETH to another address, then an EXECUTE_SUB_PLAN",
+                commands: [0x0b, 0x21],
+                inputs: [encodeWrapEth(OTHER_ADDR, ONE_ETH), SUB_PLAN],
+                lines: [
+                    ...wrapLines(OTHER_ADDR),
+                    ["Moved from the sender", UNDECODED],
+                ],
+            },
+            {
+                kind: "a WRAP_ETH of 1 ETH to address(1), then an EXECUTE_SUB_PLAN",
+                commands: [0x0b, 0x21],
+                inputs: [encodeWrapEth(MSG_SENDER, ONE_ETH), SUB_PLAN],
+                lines: [
+                    ...wrapLines("The sender"),
+                    ["Moved from the sender", UNDECODED],
+                ],
+            },
+            {
+                kind: "a PERMIT2_PERMIT of 5,000 USDT to the router, a WRAP_ETH of 1 ETH to another address, then a V3 exact-in of 600 USDT",
+                commands: [0x0a, 0x0b, 0x00],
+                inputs: [
+                    encodePermit2(USDT_ADDR, 5000000000n, ROUTER_ADDR),
+                    encodeWrapEth(OTHER_ADDR, ONE_ETH),
+                    V3_600,
+                ],
+                lines: [["Amount", "5000.0000 USDT"], ...wrapLines(OTHER_ADDR)],
+            },
+        ])("$kind", ({ commands, inputs, lines }) => {
+            const result = decodeSteps(commands, inputs);
+            expect(linesBetweenTokens(result)).toEqual(lines);
+        });
+
+        // https://git.eeqj.de/sneak/AutistMask/issues/665 — V4Router pays ETH
+        // from the router's own ETH, whoever a SETTLE names as payer. ETH the
+        // router holds from an UNWRAP_WETH into it pays first, so the sender
+        // pays only the ETH beyond it. On next each row also took the V4
+        // step's whole ETH from the sender: 1 ETH more in the first two, and
+        // 1.5 ETH in the last.
+        const unwrapIntoRouter = encodeWrapEth(ROUTER_ADDR, 0n); // UNWRAP_WETH, same encoding
+        // A V4 step swapping `amount` of ETH for USDC, with a SETTLE of
+        // OPEN_DELTA by the user.
+        const v4EthForUsdc = (amount) =>
+            encodeV4Swap(
+                new Uint8Array([
+                    V4_SWAP_EXACT_IN_SINGLE_ID,
+                    V4_SETTLE_ID,
+                    V4_TAKE_ALL_ID,
+                ]),
+                [
+                    encodeV4ExactInSingle(ZERO_ADDR, USDC_ADDR, amount, 1n),
+                    settle(ZERO_ADDR, 0n, true),
+                    encodeV4TakeAll(USDC_ADDR, 0n),
+                ],
+            );
+        test.each([
+            {
+                kind: "a V3 exact-in of 600 USDT for WETH paid to the router, an UNWRAP_WETH into the router, then a V4 swap of 1 ETH that the user settles",
+                commands: [0x00, 0x0c, 0x10],
+                inputs: [
+                    encodeV3SwapExactIn(ROUTER_ADDR, USDT_600, 1n, [
+                        USDT_ADDR,
+                        WETH_ADDR,
+                    ]),
+                    unwrapIntoRouter,
+                    v4EthForUsdc(ONE_ETH),
+                ],
+                lines: [["Amount", "600.0000 USDT"]],
+            },
+            {
+                kind: "a WRAP_ETH of 1 ETH into the router, an UNWRAP_WETH into the router, then a V4 swap of 1 ETH that the user settles",
+                commands: [0x0b, 0x0c, 0x10],
+                inputs: [
+                    encodeWrapEth(ROUTER_ADDR, ONE_ETH),
+                    unwrapIntoRouter,
+                    v4EthForUsdc(ONE_ETH),
+                ],
+                lines: [["Amount", "1.0000 ETH"]],
+            },
+            {
+                kind: "a WRAP_ETH of 1 ETH into the router, an UNWRAP_WETH into the router, then a V4 swap of 1.5 ETH that the user settles",
+                commands: [0x0b, 0x0c, 0x10],
+                inputs: [
+                    encodeWrapEth(ROUTER_ADDR, ONE_ETH),
+                    unwrapIntoRouter,
+                    v4EthForUsdc((ONE_ETH * 3n) / 2n),
+                ],
+                lines: [["Amount", "1.5000 ETH"]],
+            },
+        ])("$kind", ({ commands, inputs, lines }) => {
+            const result = decodeSteps(commands, inputs);
+            expect(linesBetweenTokens(result)).toEqual(lines);
+        });
+
         // A V3_SWAP_EXACT_OUT the user pays for, of at most `amountInMax`
         // USDT for USDC.
         const v3ExactOut = (amountInMax) =>