fix: a permit after a swap step shows on its own lines instead of replacing Token In (closes #370)

A PERMIT2_PERMIT read after a step had set the input side named Token
In, and its amount could stand as the Amount figure, so the approval
screen could show an allowance where the swap's own input belonged.

Such a permit now leaves Token In and Amount to the swap and gets three
lines of its own: Permit2 allowance, Allowance token and Allowance
spender. A permit before the swap steps works as before, and a later
permit still keeps its amount from standing. README Transaction
Decoding and the TxApproval element list match.

Model: opus-5-5

README.md

@@ -2422,10 +2422,11 @@ view would leave a wallet one click from deletion.
       transaction"
     - Decoded action (if calldata is recognized): action name, token details,
       amounts, what each swap step spends that the `Amount` line does not give,
-      what each `PERMIT2_TRANSFER_FROM` moves and where to, steps, deadline, and
+      what each `PERMIT2_TRANSFER_FROM` moves and where to, what each
-      unless a swap pays only the From address, a `Paid to` line for each other
+      `PERMIT2_PERMIT` after the step that sets the input side lets its spender
-      address it pays, or saying that a token stays in the router or who it pays
+      take, steps, deadline, and unless a swap pays only the From address, a
-      is unknown (see Transaction Decoding)
+      `Paid to` line for each other address it pays, or saying that a token
+      stays in the router or who it pays is unknown (see Transaction Decoding)
     - From: color dot + full address + etherscan link
     - Contract: color dot + full address + etherscan link, token symbol label if
       known; for a contract creation, the same sentence as on WaitTx
@@ -3215,37 +3216,37 @@ Currently supported:
   V2 exact-in of 400 USDT, both paid by the user, read `1000.0000 USDT`. When
   the decoder does not know a take's amount, the total is not known and there is
   no `Amount` line. `Token In` is the token of the last `PERMIT2_PERMIT` the
-  decoder reads, when there is one. Its amount, `Unlimited` included, stands as
+  decoder reads before the step that sets the input side, when there is one. Its
-  the `Amount` figure in place of the total only in the plain shape of Uniswap's
+  amount, `Unlimited` included, stands as the `Amount` figure in place of the
-  own routes: it is the only `PERMIT2_PERMIT`, its spender is the router, the
+  total only in the plain shape of Uniswap's own routes: it is the only
-  router may not let it fail, no step before it takes its token or a token the
+  `PERMIT2_PERMIT` in the transaction, its spender is the router, the router may
-  decoder does not know, and the decoder reads every step after it in full.
+  not let it fail, no step before it takes its token or a token the decoder does
-  Permit2 then lets the router take no more of the token than that amount, so
+  not know, and the decoder reads every step after it in full. Permit2 then lets
-  the permit covers every take of it. A step the decoder does not read in full
+  the router take no more of the token than that amount, so the permit covers
-  may raise what Permit2 lets the router take, as a `PERMIT2_PERMIT_BATCH` can:
+  every take of it. A step the decoder does not read in full may raise what
-  a command the decoder does not read (listed at the end of this section), a
+  Permit2 lets the router take, as a `PERMIT2_PERMIT_BATCH` can: a command the
-  step whose input it cannot read, in whole or in part, and a step it fails on.
+  decoder does not read (listed at the end of this section), a step whose input
-  In any other case the line gives the total, as with no permit. When the step
+  it cannot read, in whole or in part, and a step it fails on. In any other case
-  that sets the input side spends a token other than the permit's, or one the
+  the line gives the total, as with no permit. When the step that sets the input
-  decoder does not know, its amount gets lines of its own, unless it states no
+  side spends a token other than the permit's, or one the decoder does not know,
-  amount and the user pays it none of its input token, and the total has no
+  its amount gets lines of its own, unless it states no amount and the user pays
-  figure to start from: unless the permit's amount stands there is no `Amount`
+  it none of its input token, and the total has no figure to start from: unless
-  line, and each take of the permit's token gets lines of its own. Each take the
+  the permit's amount stands there is no `Amount` line, and each take of the
-  total does not count gives three lines after the `Amount` line (after
+  permit's token gets lines of its own. Each take the total does not count gives
-  `Token In` when there is none): one of a token other than `Token In`; one of
+  three lines after the `Amount` line (after `Token In` when there is none): one
-  `Token In` after an amount that is not a quantity (a V4 open delta,
+  of a token other than `Token In`; one of `Token In` after an amount that is
-  `ALREADY_PAID`, which keep their wording on the `Amount` line, or no stated
+  not a quantity (a V4 open delta, `ALREADY_PAID`, which keep their wording on
-  amount, as of a V4 exact-out step); and one whose amount the decoder does not
+  the `Amount` line, or no stated amount, as of a V4 exact-out step); and one
-  know. When the step that sets the input side states no amount, the user pays
+  whose amount the decoder does not know. When the step that sets the input side
-  it some of its input token, and there is no `Amount` line, that step gets them
+  states no amount, the user pays it some of its input token, and there is no
-  too whenever another take's lines give a figure, or a `PERMIT2_TRANSFER_FROM`
+  `Amount` line, that step gets them too whenever another take's lines give a
-  of its token gives one, on the lines below or, into the router, on its
+  figure, or a `PERMIT2_TRANSFER_FROM` of its token gives one, on the lines
-  `Paid to` line, so that figure cannot read as all that leaves. When it states
+  below or, into the router, on its `Paid to` line, so that figure cannot read
-  no amount and the user pays it none of its input token, as when the router
+  as all that leaves. When it states no amount and the user pays it none of its
-  pays it, that step takes none of that token from the user's wallet and never
+  input token, as when the router pays it, that step takes none of that token
-  gets them, with a permit or without. They come in step order, the step that
+  from the user's wallet and never gets them, with a permit or without. They
-  sets the input side first when it has them: `Moved from the sender`, its
+  come in step order, the step that sets the input side first when it has them:
-  amount, worded as the `Amount` line words one, or
+  `Moved from the sender`, its amount, worded as the `Amount` line words one, or
   `Unknown (could not be decoded)` when the decoder does not know it;
   `Token moved`, giving the token's address as the `Token In` line does; and
   `Moved to`, which reads `The swap step that spends it`. A token the decoder
@@ -3268,15 +3269,23 @@ Currently supported:
   on every router but `UniversalRouterV1`, and otherwise gives the address. A
   move into the router needs none of them, because its `Paid to` line and
   `Token moved into the router` line already give the amount, the token and
-  where it goes, and so its amount is shown once. These lines change neither the
+  where it goes, and so its amount is shown once. A `PERMIT2_PERMIT` after the
-  `Paid to` lines nor the minimum's label. A step goes unread when its recipient
+  step that sets the input side names neither `Token In` nor the `Amount`
-  does not decode as an address, when it is a V3 swap step whose path is shorter
+  figure, which keep that step's token and the total: a V3 exact-in of 600 USDT
-  than one token address or has bytes after its last hop, or when it is a
+  followed by a permit of 5,000 DAI reads `Swap USDT → USDC` with
-  command the decoder does not read: every command other than `PERMIT2_PERMIT`,
+  `Amount 600.0000 USDT`. Each such permit, in step order, gives three lines
-  `PERMIT2_TRANSFER_FROM`, `V2_SWAP_EXACT_IN`, `V2_SWAP_EXACT_OUT`,
+  after those for each `PERMIT2_TRANSFER_FROM`: `Permit2 allowance`, its amount,
-  `V3_SWAP_EXACT_IN`, `V3_SWAP_EXACT_OUT`, `V4_SWAP`, `SWEEP`, `TRANSFER`,
+  for example `5000.0000 DAI`, or `Unlimited` for Permit2's maximum;
-  `PAY_PORTION`, `PAY_PORTION_FULL_PRECISION`, `ACROSS_V4_DEPOSIT_V3`,
+  `Allowance token`, giving the token's address as the `Token In` line does; and
-  `WRAP_ETH`, `UNWRAP_WETH` and `BALANCE_CHECK_ERC20`
+  `Allowance spender`, the address it lets take the token. These lines change
+  neither the `Paid to` lines nor the minimum's label. A step goes unread when
+  its recipient does not decode as an address, when it is a V3 swap step whose
+  path is shorter than one token address or has bytes after its last hop, or
+  when it is a command the decoder does not read: every command other than
+  `PERMIT2_PERMIT`, `PERMIT2_TRANSFER_FROM`, `V2_SWAP_EXACT_IN`,
+  `V2_SWAP_EXACT_OUT`, `V3_SWAP_EXACT_IN`, `V3_SWAP_EXACT_OUT`, `V4_SWAP`,
+  `SWEEP`, `TRANSFER`, `PAY_PORTION`, `PAY_PORTION_FULL_PRECISION`,
+  `ACROSS_V4_DEPOSIT_V3`, `WRAP_ETH`, `UNWRAP_WETH` and `BALANCE_CHECK_ERC20`
   (`PERMIT2_TRANSFER_FROM_BATCH`, `EXECUTE_SUB_PLAN` and the NFT commands among
   them), or a type its release names no command for.
 

src/shared/uniswap.js

@@ -494,8 +494,9 @@ function amountText(raw, info) {
     };
 }
 
-// The line giving a moved token under `label`, in the shape of the Token In
+// The line giving a moved token, or the token of a permit, under `label`, in
-// line, so the screens show it as they show that one. ETH has no address.
+// the shape of the Token In line, so the screens show it as they show that
+// one. ETH has no address.
 function tokenMovedLine(label, token, sources) {
     const info = tokenInfo(token, sources);
     if (!present(info.address)) {
@@ -1208,9 +1209,12 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // its input currency (see decodeV4Swap()). Only a V4 step can set the
         // input side with no amount, the one case in which this is read.
         let inputPaidByUser = false;
-        // The last PERMIT2_PERMIT this decoder read, or null (see
+        // The last PERMIT2_PERMIT this decoder read before a step set the
-        // permitStands after the loop).
+        // input side, or null (see permitStands after the loop).
         let permit = null;
+        // Each PERMIT2_PERMIT this decoder read after a step set the input
+        // side, in step order (see the PERMIT2_PERMIT branch in the loop).
+        const permitsAfterInput = [];
         // The index of each step this decoder did not read in full: a
         // command it does not read, a step whose input it cannot read, in
         // whole or in part, and one it fails on (see permitStands).
@@ -1268,8 +1272,9 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // when no earlier hop set it. A half the establishing hop did not
         // state stays null and the line says so, rather than being filled in
         // from a different hop. A PERMIT2_PERMIT sets no side here: after the
-        // loop, the last one read names Token In, and the Amount line is
+        // loop, the last one read before a step set the input side names
-        // formed there, in one place (see permitStands).
+        // Token In, and the Amount line is formed there, in one place (see
+        // permitStands).
         const setInput = (token, amount) => {
             inputToken = present(token) ? token : null;
             inputAmount = present(amount) ? amount : null;
@@ -1464,16 +1469,24 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
                     spentUnread();
                 } else if (command === "PERMIT2_PERMIT") {
                     const p = decodePermit2(inputs[i]);
-                    if (p) {
+                    if (p && inputEstablished) {
+                        // After a step set the input side, a permit names
+                        // neither Token In nor the Amount figure: the swap's
+                        // own input token and amount stay on those lines, and
+                        // the permit's token, amount and spender get lines
+                        // of their own.
+                        permitsAfterInput.push(p);
+                        keepsRouterWeth = true;
+                    } else if (p) {
                         // Whether a step before it took its token, or may
-                        // have: the step that set the input side or one in
+                        // have: one in `userPaid`, when its token is the
-                        // `userPaid`, when its token is the permit's or not
+                        // permit's or not known. No step has set the input
-                        // known.
+                        // side yet.
                         const mayBeItsToken = (token) =>
                             !present(token) || sameAddress(token, p.token);
-                        const tookBefore =
+                        const tookBefore = userPaid.some((t) =>
-                            (inputEstablished && mayBeItsToken(inputToken)) ||
+                            mayBeItsToken(t.token),
-                            userPaid.some((t) => mayBeItsToken(t.token));
+                        );
                         permit = {
                             ...p,
                             step: i,
@@ -1939,18 +1952,21 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
         // lines of its own. One whose amount is not known also leaves the
         // total unknown, with no figure.
         //
-        // The last PERMIT2_PERMIT read names Token In. Its amount stands as
+        // The last PERMIT2_PERMIT read before a step set the input side names
-        // the Amount figure in place of the total only in the plain shape of
+        // Token In. Its amount stands as the Amount figure in place of the
-        // Uniswap's own routes: it is the only PERMIT2_PERMIT, its spender is
+        // total only in the plain shape of Uniswap's own routes: it is the
-        // the router, the router may not let it fail, no step before it took
+        // only PERMIT2_PERMIT in the transaction, its spender is the router,
-        // its token or one not known, and this decoder read every step after
+        // the router may not let it fail, no step before it took its token or
-        // it in full (see stepsUnread). Permit2 then lets the router take no
+        // one not known, and this decoder read every step after it in full
-        // more of the token than that amount, so the permit covers every take
+        // (see stepsUnread). Permit2 then lets the router take no more of the
-        // of it. A later step this decoder did not read may raise what Permit2
+        // token than that amount, so the permit covers every take of it. A
-        // lets the router take, as a PERMIT2_PERMIT_BATCH can. A step that
+        // later step this decoder did not read may raise what Permit2 lets
-        // may take from the sender what this decoder did not read leaves no
+        // the router take, as a PERMIT2_PERMIT_BATCH can. A step that may
+        // take from the sender what this decoder did not read leaves no
         // figure, permit or not (see spentUnread()), and an EXECUTE_SUB_PLAN
-        // step leaves both sides unknown (below).
+        // step leaves both sides unknown (below). A PERMIT2_PERMIT after a
+        // step set the input side counts among the PERMIT2_PERMITs here, and
+        // gets lines of its own below.
         const stepCommands = Array.from(
             commandsBytes,
             (b) => commands[b & commandTypeMask],
@@ -2181,6 +2197,26 @@ function decode(data, toAddress, chainId, sources, fromAddress) {
             );
         }
 
+        // What each PERMIT2_PERMIT after the step that set the input side
+        // lets its spender take: its amount, its token and the spender, an
+        // address on a line of its own. Permit2's maximum is unbounded.
+        for (const p of permitsAfterInput) {
+            details.push({
+                label: "Permit2 allowance",
+                value:
+                    p.amount >= MAX_UINT160
+                        ? "Unlimited"
+                        : amountText(p.amount, tokenInfo(p.token, sources))
+                              .display,
+            });
+            details.push(tokenMovedLine("Allowance token", p.token, sources));
+            details.push({
+                label: "Allowance spender",
+                value: p.spender,
+                address: p.spender,
+            });
+        }
+
         // Keyed on the address, not the symbol: a token absent from the
         // bundled list has no symbol, and gating the line on one dropped it
         // entirely, leaving a Min. received figure with nothing saying what is

tests/uniswap.test.js

@@ -1,4 +1,4 @@
-const { AbiCoder, Interface, solidityPacked } = require("ethers");
+const { AbiCoder, Interface, getAddress, solidityPacked } = require("ethers");
 const uniswap = require("../src/shared/uniswap");
 
 // A Universal Router on Ethereum Mainnet, chain id 0x1: UniversalRouterV2,
@@ -2168,8 +2168,8 @@ describe("uniswap decoder", () => {
         ];
         // What a V3_SWAP_EXACT_OUT takes, at most its amountInMax, counts
         // as a V2_SWAP_EXACT_OUT's does, and the Amount line is a maximum.
-        // The permit of 10,000 USDT stands; the one of 600 USDT does not,
+        // The permit of 10,000 USDT stands. The one of 600 USDT comes after
-        // because the step before it took its token.
+        // the step that set the input side, so it gets lines of its own.
         test.each([
             {
                 kind: "a V3 exact-in of 600 USDT, then a V3_SWAP_EXACT_OUT of at most 400 USDT",
@@ -2201,17 +2201,118 @@ describe("uniswap decoder", () => {
                     V3_600,
                 ],
                 amount: "Up to 10000.0000 USDT",
+                permitLines: [
+                    ["Permit2 allowance", "600.0000 USDT"],
+                    ["Allowance token", "USDT (" + USDT_ADDR + ")"],
+                    ["Allowance spender", getAddress(ROUTER_ADDR)],
+                ],
             },
         ])(
             "$kind, all paid by the user, shows the total as a maximum",
-            ({ commands, inputs, amount }) => {
+            ({ commands, inputs, amount, permitLines = [] }) => {
                 const result = decodeSteps(commands, inputs);
                 expect(linesBetweenTokens(result)).toEqual([
                     ["Amount", amount],
+                    ...permitLines,
                 ]);
             },
         );
 
+        // https://git.eeqj.de/sneak/AutistMask/issues/370 — a PERMIT2_PERMIT
+        // after the step that set the input side named Token In in place of
+        // that step's token, and its amount could stand as the Amount figure.
+        // The swap's own token and amount now stay on those lines, and the
+        // permit gets lines of its own.
+        describe("a PERMIT2_PERMIT after the step that sets the input side", () => {
+            const DAI_5000 = 5000000000000000000000n;
+            const MAX_UINT160 = 2n ** 160n - 1n;
+            // The permit's lines, for `amount` of `token` and `spender`.
+            const permitLines = (amount, token, symbol, spender) => [
+                ["Permit2 allowance", amount],
+                ["Allowance token", symbol + " (" + token + ")"],
+                ["Allowance spender", getAddress(spender)],
+            ];
+
+            test.each([
+                {
+                    kind: "of 5,000 DAI to the router",
+                    permit: encodePermit2(DAI_ADDR, DAI_5000, ROUTER_ADDR),
+                    lines: permitLines(
+                        "5000.0000 DAI",
+                        DAI_ADDR,
+                        "DAI",
+                        ROUTER_ADDR,
+                    ),
+                },
+                {
+                    kind: "of unlimited DAI to another spender",
+                    permit: encodePermit2(DAI_ADDR, MAX_UINT160, OTHER_ADDR),
+                    lines: permitLines(
+                        "Unlimited",
+                        DAI_ADDR,
+                        "DAI",
+                        OTHER_ADDR,
+                    ),
+                },
+                {
+                    kind: "of 600 USDT, the swap's own token, to the router",
+                    permit: encodePermit2(USDT_ADDR, USDT_600, ROUTER_ADDR),
+                    lines: permitLines(
+                        "600.0000 USDT",
+                        USDT_ADDR,
+                        "USDT",
+                        ROUTER_ADDR,
+                    ),
+                },
+            ])(
+                "a V3 exact-in of 600 USDT, then a PERMIT2_PERMIT $kind, shows the swap's USDT and the permit's own lines",
+                ({ permit, lines }) => {
+                    const result = decodeSteps([0x00, 0x0a], [V3_600, permit]);
+                    expect(result.name).toBe("Swap USDT → USDC");
+                    expect(
+                        detail(result, "Token In").address.toLowerCase(),
+                    ).toBe(USDT_ADDR.toLowerCase());
+                    expect(linesBetweenTokens(result)).toEqual([
+                        ["Amount", "600.0000 USDT"],
+                        ...lines,
+                    ]);
+                    expect(detail(result, "Amount").rawValue).toBe("600.0000");
+                },
+            );
+
+            // The permit before the swap steps still names Token In. With a
+            // second permit its amount does not stand, so the Amount line
+            // gives the total the steps take of USDT, and the 400 DAI the
+            // last step takes gets lines of its own.
+            test("a PERMIT2_PERMIT of USDT, a V3 exact-in of 600 USDT, a PERMIT2_PERMIT of DAI and a V2 exact-in of 400 DAI shows both tokens' amounts and the second permit's own lines", () => {
+                const result = decodeSteps(
+                    [0x0a, 0x00, 0x0a, 0x08],
+                    [
+                        encodePermit2(USDT_ADDR, 5000000000n, ROUTER_ADDR),
+                        V3_600,
+                        encodePermit2(DAI_ADDR, DAI_400, ROUTER_ADDR),
+                        encodeV2SwapExactIn(USER_ADDR, DAI_400, 390000000n, [
+                            DAI_ADDR,
+                            USDC_ADDR,
+                        ]),
+                    ],
+                );
+                expect(result.name).toBe("Swap USDT → USDC");
+                expect(linesBetweenTokens(result)).toEqual([
+                    ["Amount", "600.0000 USDT"],
+                    ["Moved from the sender", "400.0000 DAI"],
+                    ["Token moved", "DAI (" + DAI_ADDR + ")"],
+                    ["Moved to", "The swap step that spends it"],
+                    ...permitLines(
+                        "400.0000 DAI",
+                        DAI_ADDR,
+                        "DAI",
+                        ROUTER_ADDR,
+                    ),
+                ]);
+            });
+        });
+
         // A V3_SWAP_EXACT_OUT whose path is shorter than one token cannot be
         // read. It may pay any address and take from the sender, so it
         // leaves no Amount figure.