fix: closing a transaction or signature approval window leaves the request pending (closes #673)

Closing a transaction or signature approval window no longer rejects the request; only Cancel does. The browser can close that window when the user clicks away, for example to copy the password from a password manager. The request stays pending and the site gets no answer. Pressing the toolbar button opens the oldest such request, unless an approved attempt still holds it. A Reject the background refuses keeps the window open with the background's message. The worker points the toolbar back at the wallet when it starts.

While such a request waits, the transaction slot stays held, so another site's eth_sendTransaction gets -32002. An address switch still rejects pending approvals with 4001.

Model: opus-5-5

tests/backgroundApproval.test.js

@@ -241,10 +241,11 @@ function loadBackground(options) {
     let connectListener = null;
     const created = [];
     const removed = [];
-    // Every URL the background put on the browser action. A site approval
-    // raised through action.openPopup() opens no window at all, so this is
-    // the only place its id appears.
-    const actionPopups = [];
+    // Every URL the background put on the browser action. When a test gives
+    // the URL the action holds before the worker starts, that URL comes
+    // first. A site approval raised through action.openPopup() opens no
+    // window at all, so this is the only place its id appears.
+    const actionPopups = opts.toolbarPopup ? [opts.toolbarPopup] : [];
     const openPopup = jest.fn(() => Promise.resolve());
 
     global.chrome = {
@@ -774,10 +775,9 @@ describe("one transaction approval at a time", () => {
 
     // The user closes an approval window that looks hung while the attempt
     // behind it is still running, and that attempt then fails in a way that
-    // would normally leave the approval standing for a retry. There is no
-    // window left to retry in, so leaving it standing answers the requesting
-    // page never — and holds the slot for the life of the worker with it.
-    test("an approval whose window closed under a failed attempt is answered, and frees the next request", async () => {
+    // leaves the approval standing for a retry. The toolbar popup opens it, so
+    // the user can still retry it, and answering it frees the slot.
+    test("an approval whose window closed under a failed attempt is retried from the toolbar popup, and frees the next request", async () => {
         const stalled = deferred();
         const bg = loadBackground();
 
@@ -808,11 +808,28 @@ describe("one transaction approval at a time", () => {
 
         stalled.resolve();
         await settle();
-        expect(first.result()).toEqual({
-            error: { code: 4001, message: "User rejected the request." },
-        });
+        expect(first.result()).toBeNull();
+        expect(bg.actionPopups[bg.actionPopups.length - 1]).toBe(
+            "src/popup/index.html?approval=" + first.id(),
+        );
 
         bg.setStateReadHook(null);
+        bg.broadcastTransaction.mockResolvedValue({ hash: "0xfeed" });
+        bg.send(
+            {
+                type: "AUTISTMASK_TX_RESPONSE",
+                id: first.id(),
+                approved: true,
+                rawSignedTx: await signedAtNonce(NONCE),
+            },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(first.result()).toEqual({ result: "0xfeed" });
+        expect(bg.actionPopups[bg.actionPopups.length - 1]).toBe(
+            "src/popup/index.html",
+        );
+
         const second = bg.requestTx();
         await settle();
         expect(second.result()).toBeNull();
@@ -853,8 +870,10 @@ describe("one transaction approval at a time", () => {
         const first = bg.requestTx();
         await settle();
 
-        // The user closes the approval window, which rejects it.
-        bg.closeWindow(1);
+        bg.send(
+            { type: "AUTISTMASK_TX_RESPONSE", id: first.id(), approved: false },
+            { url: bg.fromPopup.url },
+        );
         await settle();
         expect(first.result()).toEqual({
             error: { code: 4001, message: "User rejected the request." },
@@ -897,7 +916,7 @@ describe("the worker keeps running while an approval is pending", () => {
         try {
             const bg = loadBackground();
             const calls = global.chrome.runtime.getPlatformInfo;
-            bg.requestTx();
+            const pending = bg.requestTx();
             await settle();
             expect(startTimer).toHaveBeenCalledTimes(1);
             expect(startTimer.mock.calls[0][1]).toBe(20000);
@@ -906,11 +925,23 @@ describe("the worker keeps running while an approval is pending", () => {
             tick();
             expect(calls).toHaveBeenCalledTimes(1);
 
-            // The user closes the approval window, which rejects it.
+            // A closed window leaves the approval pending, so the calls go on.
             bg.closeWindow(1);
             await settle();
             tick();
-            expect(calls).toHaveBeenCalledTimes(1);
+            expect(calls).toHaveBeenCalledTimes(2);
+
+            bg.send(
+                {
+                    type: "AUTISTMASK_TX_RESPONSE",
+                    id: pending.id(),
+                    approved: false,
+                },
+                { url: bg.fromPopup.url },
+            );
+            await settle();
+            tick();
+            expect(calls).toHaveBeenCalledTimes(2);
             expect(stopTimer).toHaveBeenCalledWith(1);
         } finally {
             startTimer.mockRestore();
@@ -1841,6 +1872,237 @@ describe("the interlock releases a failed attempt", () => {
     });
 });
 
+// A transaction or signature approval stays pending when its window closes.
+// The browser can close that window when the user clicks away from it, for
+// example to copy the password from a password manager. The toolbar popup then
+// opens the approval, and the user answers it there
+// (https://git.eeqj.de/sneak/AutistMask/issues/673).
+describe("a closed approval window leaves the request pending", () => {
+    // The URL the toolbar popup opens now.
+    function toolbarPopup(bg) {
+        return bg.actionPopups[bg.actionPopups.length - 1];
+    }
+
+    // The timer that keeps the worker running while an approval is pending is
+    // stubbed, so no test here leaves that timer running when it ends.
+    let keepRunningTimer;
+    beforeEach(() => {
+        keepRunningTimer = jest
+            .spyOn(global, "setInterval")
+            .mockImplementation(() => 1);
+    });
+    afterEach(() => {
+        keepRunningTimer.mockRestore();
+    });
+
+    test("the toolbar popup opens a closed transaction approval, and approving it there sends", async () => {
+        const bg = loadBackground();
+        const pending = bg.requestTx();
+        await settle();
+
+        bg.closeWindow(1);
+        await settle();
+        expect(pending.result()).toBeNull();
+        expect(toolbarPopup(bg)).toBe(
+            "src/popup/index.html?approval=" + pending.id(),
+        );
+
+        bg.broadcastTransaction.mockResolvedValue({ hash: "0xfeed" });
+        bg.send(
+            {
+                type: "AUTISTMASK_TX_RESPONSE",
+                id: pending.id(),
+                approved: true,
+                rawSignedTx: await signedAtNonce(NONCE),
+            },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(pending.result()).toEqual({ result: "0xfeed" });
+        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
+    });
+
+    test("Reject in the toolbar popup answers 4001, and the toolbar popup opens the wallet again", async () => {
+        const bg = loadBackground();
+        const pending = bg.requestSign();
+        await settle();
+
+        bg.closeWindow(1);
+        await settle();
+        expect(pending.result()).toBeNull();
+        expect(toolbarPopup(bg)).toBe(
+            "src/popup/index.html?approval=" + pending.id(),
+        );
+
+        const reject = bg.send(
+            {
+                type: "AUTISTMASK_SIGN_RESPONSE",
+                id: pending.id(),
+                approved: false,
+            },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(pending.result()).toEqual({
+            error: { code: 4001, message: "User rejected the request." },
+        });
+        // The popup closes its window only once this answer arrives.
+        expect(reject.sendResponse).toHaveBeenCalledWith(null);
+        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
+    });
+
+    test("with two closed, the toolbar popup opens the older one first, then the other", async () => {
+        const bg = loadBackground();
+        const sign = bg.requestSign();
+        await settle();
+        const signId = sign.id();
+        const tx = bg.requestTx();
+        await settle();
+
+        // The signature request is in window 1 and the transaction in window
+        // 2. The newer window is closed first.
+        bg.closeWindow(2);
+        bg.closeWindow(1);
+        await settle();
+        expect(toolbarPopup(bg)).toBe(
+            "src/popup/index.html?approval=" + signId,
+        );
+
+        bg.send(
+            { type: "AUTISTMASK_SIGN_RESPONSE", id: signId, approved: false },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(toolbarPopup(bg)).toBe(
+            "src/popup/index.html?approval=" + tx.id(),
+        );
+
+        const reject = bg.send(
+            { type: "AUTISTMASK_TX_RESPONSE", id: tx.id(), approved: false },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(tx.result()).toEqual({
+            error: { code: 4001, message: "User rejected the request." },
+        });
+        expect(reject.sendResponse).toHaveBeenCalledWith(null);
+        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
+    });
+
+    // The user can close the window while the attempt after Confirm runs. That
+    // attempt answers the request, so meanwhile the toolbar popup opens the
+    // wallet. Opened from the toolbar, the approval would look unanswered.
+    test("when the window closes during an attempt that sends, the toolbar popup keeps opening the wallet", async () => {
+        const bg = loadBackground();
+        const pending = bg.requestTx();
+        await settle();
+
+        const inFlight = deferred();
+        bg.broadcastTransaction.mockReturnValue(inFlight.promise);
+        bg.send(
+            {
+                type: "AUTISTMASK_TX_RESPONSE",
+                id: pending.id(),
+                approved: true,
+                rawSignedTx: await signedAtNonce(NONCE),
+            },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        bg.closeWindow(1);
+        await settle();
+        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
+
+        inFlight.resolve({ hash: "0xfeed" });
+        await settle();
+        expect(pending.result()).toEqual({ result: "0xfeed" });
+        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
+    });
+
+    test("when the window closes during an attempt that fails retryably, the toolbar popup opens the wallet until the attempt ends, then the approval", async () => {
+        const stalled = deferred();
+        const bg = loadBackground();
+        const pending = bg.requestTx();
+        await settle();
+
+        bg.setStateReadHook(async () => {
+            await stalled.promise;
+            throw new Error("The wallet data could not be read.");
+        });
+        bg.send(
+            {
+                type: "AUTISTMASK_TX_RESPONSE",
+                id: pending.id(),
+                approved: true,
+                rawSignedTx: await signedAtNonce(NONCE),
+            },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        bg.closeWindow(1);
+        await settle();
+        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
+
+        stalled.resolve();
+        await settle();
+        expect(pending.result()).toBeNull();
+        expect(toolbarPopup(bg)).toBe(
+            "src/popup/index.html?approval=" + pending.id(),
+        );
+
+        // A retry from the toolbar popup holds the approval again, so the
+        // toolbar popup opens the wallet while that retry runs.
+        bg.setStateReadHook(null);
+        const inFlight = deferred();
+        bg.broadcastTransaction.mockReturnValue(inFlight.promise);
+        bg.send(
+            {
+                type: "AUTISTMASK_TX_RESPONSE",
+                id: pending.id(),
+                approved: true,
+                rawSignedTx: await signedAtNonce(NONCE),
+            },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
+
+        inFlight.resolve({ hash: "0xfeed" });
+        await settle();
+        expect(pending.result()).toEqual({ result: "0xfeed" });
+        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
+    });
+
+    test("an address switch still rejects a closed approval", async () => {
+        const bg = loadBackground();
+        const pending = bg.requestTx();
+        await settle();
+        bg.closeWindow(1);
+        await settle();
+        expect(pending.result()).toBeNull();
+
+        bg.send(
+            { type: "AUTISTMASK_ACTIVE_CHANGED" },
+            { url: bg.fromPopup.url },
+        );
+        await settle();
+        expect(pending.result()).toEqual({
+            error: { code: 4001, message: "User rejected the request." },
+        });
+        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
+    });
+
+    // The worker can stop while an approval waits with its window closed. The
+    // approval is lost with the worker, but the toolbar popup keeps its URL.
+    // The next worker points the toolbar popup back at the wallet.
+    test("a worker that starts points the toolbar popup back at the wallet", () => {
+        const bg = loadBackground({
+            toolbarPopup: "src/popup/index.html?approval=lost-approval",
+        });
+        expect(toolbarPopup(bg)).toBe("src/popup/index.html");
+    });
+});
+
 // The claim is what makes one approval one broadcast, so it has to hold
 // against everything else that retires an approval, not just against a second
 // AUTISTMASK_TX_RESPONSE. Each of these paths used to resolve the waiting
@@ -1961,20 +2223,6 @@ describe("a claimed approval outlives every other retirement path", () => {
     });
 
     // The refusals above must not cost the rejection its ordinary meaning.
-    test("with no attempt running, closing the window still rejects", async () => {
-        const bg = loadBackground();
-        const pending = bg.requestTx();
-        await settle();
-
-        bg.closeWindow(1);
-        await settle();
-
-        expect(pending.result()).toEqual({
-            error: { code: 4001, message: "User rejected the request." },
-        });
-        expect(bg.broadcastTransaction).not.toHaveBeenCalled();
-    });
-
     test("with no attempt running, an active-address switch still rejects and closes", async () => {
         const bg = loadBackground();
         const pending = bg.requestTx();
@@ -2584,15 +2832,12 @@ describe("a site connection decided as the popup closes", () => {
         });
     });
 
-    // The `isSite &&` half of that skip, which is what keeps it from reaching
-    // a tx or sign approval. The popup connects its port in show() before it
-    // knows the approval's type, and the background sets portConnected without
-    // looking at the type either, so a tx approval in the fallback window
-    // carries the flag too. Without the conjunct the window event would skip
-    // it, windowClosed would never be set, releaseApproval() would never settle
-    // it, and the page would hang — the #271 regression this guard is written
-    // around.
-    test("a tx window closed with the port connected still rejects", async () => {
+    // That skip must not reach a tx or sign approval. The popup connects its
+    // port in show() before it knows the approval's type, and the background
+    // sets portConnected without looking at the type either, so a tx approval
+    // carries the flag too. If the window event skipped it, windowClosed would
+    // never be set, and the toolbar popup would never open the approval.
+    test("a tx window closed with the port connected is still opened by the toolbar popup", async () => {
         const bg = loadBackground();
         const pending = bg.requestTx();
         await settle();
@@ -2600,9 +2845,10 @@ describe("a site connection decided as the popup closes", () => {
         await settle();
         bg.closeWindow(1);
         await settle();
-        expect(pending.result()).toEqual({
-            error: { code: 4001, message: "User rejected the request." },
-        });
+        expect(pending.result()).toBeNull();
+        expect(bg.actionPopups[bg.actionPopups.length - 1]).toBe(
+            "src/popup/index.html?approval=" + pending.id(),
+        );
     });
 });
 
@@ -2994,13 +3240,14 @@ describe("where an approval window opens", () => {
         expect(bg.created[1].left).toBeUndefined();
         expect(bg.created[1].top).toBeUndefined();
 
-        // The request waits on the second window rather than failing:
-        // closing that window is refusing the prompt.
+        // The request waits on the second window rather than failing. Once
+        // that window closes, the toolbar popup opens the request.
         expect(sign.result()).toBeNull();
         bg.closeWindow(2);
         await settle();
-        expect(sign.result()).toEqual({
-            error: { code: 4001, message: "User rejected the request." },
-        });
+        expect(sign.result()).toBeNull();
+        expect(bg.actionPopups[bg.actionPopups.length - 1]).toBe(
+            "src/popup/index.html?approval=" + sign.id(),
+        );
     });
 });