ci(release): publish latest release

Author: hello-happy-puppy

RELEASE

@@ -4,5 +4,5 @@ Flashblocks on Unichain: This infra upgrade brings 200ms blocktimes to the netwo
 
 Other changes: 
 
-- Improved virtual keyboard behavior
+- Fixed visual glitches in token selector
 - Various bug fixes and performance improvements

VERSION

@@ -1 +1 @@
-mobile/1.56
+extension/1.26.0

apps/extension/src/background/backgroundDappRequests.ts

@@ -9,7 +9,7 @@ import {
   GetCapabilitiesRequest,
   RevokePermissionsRequest,
 } from 'src/app/features/dappRequests/types/DappRequestTypes'
-import { focusOrCreateOnboardingTab } from 'src/app/navigation/utils'
+import { focusOrCreateDappRequestWindow, focusOrCreateOnboardingTab } from 'src/app/navigation/utils'
 import {
   DappBackgroundPortChannel,
   contentScriptToBackgroundMessageChannel,
@@ -22,7 +22,6 @@ import {
   ContentScriptUtilityMessageType,
   DappRequestMessage,
 } from 'src/background/messagePassing/types/requests'
-import { openSidePanel } from 'src/background/utils/chromeSidePanelUtils'
 import { checkAreMigrationsPending, readReduxStateFromStorage } from 'src/background/utils/persistedStateUtils'
 import { getFeatureFlaggedChainIds } from 'uniswap/src/features/chains/hooks/useFeatureFlaggedChainIds'
 import { getEnabledChains, hexadecimalStringToInt, toSupportedChainId } from 'uniswap/src/features/chains/utils'
@@ -37,6 +36,20 @@ import { Keyring } from 'wallet/src/features/wallet/Keyring/Keyring'
 import { walletContextValue } from 'wallet/src/features/wallet/context'
 import { selectHasSmartWalletConsent } from 'wallet/src/features/wallet/selectors'
 
+// Request classification constants for determining which requests need user interaction
+const REQUEST_CLASSIFICATION = {
+  interactive: new Set([
+    DappRequestType.RequestAccount,
+    DappRequestType.SendTransaction,
+    DappRequestType.SignMessage,
+    DappRequestType.SignTypedData,
+    DappRequestType.UniswapOpenSidebar,
+    DappRequestType.RequestPermissions,
+    DappRequestType.SendCalls,
+  ]),
+  silent: new Set([DappRequestType.ChangeChain, DappRequestType.RevokePermissions, DappRequestType.GetCapabilities]),
+} as const
+
 const INACTIVITY_ALARM_NAME = 'inactivity'
 // TODO(EXT-546): add a setting to turn off the auto-lock setting
 const INACTIVITY_TIMEOUT_MINUTES = 60 * 24 // 1 day
@@ -93,39 +106,79 @@ export function initMessageBridge(): void {
     return
   }
 
-  contentScriptToBackgroundMessageChannel.addAllMessageListener(async (message, sender) => {
-    // The side panel needs to be opened here because it has to be in response to a user action.
-    // Further down in the chain it will be opened in response to a message from the background script.
+  contentScriptToBackgroundMessageChannel.addAllMessageListener((message, sender) => {
+    // CRITICAL: This listener must NOT be async to preserve user gesture context.
+    // Chrome's sidePanel.open() API requires execution within ~1ms of a user gesture.
+    // Using async/await here breaks the gesture context and causes the error:
+    // "sidePanel.open() may only be called in response to a user gesture"
 
-    if (sender?.tab?.id === undefined || sender.tab.url === undefined) {
+    // Validate sender has required information
+    if (!isValidSender(sender)) {
       logger.error(new Error('sender.tab id or url is not defined'), {
         tags: {
-          file: 'background/background.ts',
+          file: 'backgroundDappRequests.ts',
           function: 'dappMessageListener',
         },
       })
       return
     }
 
-    const senderTabInfo = {
-      id: sender.tab.id,
-      url: sender.tab.url,
-      favIconUrl: sender.tab.favIconUrl,
-    }
-
-    const isSidebarActive = Boolean(windowIdToSidebarPortMap.get(sender.tab.windowId.toString()))
-    if (!isSidebarActive) {
-      const handled = await handleSilentBackgroundRequest(message, senderTabInfo)
-      if (handled) {
-        return
-      }
+    const requestType = message.type
+    const windowId = sender.tab.windowId
+    const windowIdString = windowId.toString()
+    const isSidebarActive = Boolean(windowIdToSidebarPortMap.get(windowIdString))
+
+    // CRITICAL: Open side panel synchronously to preserve user gesture context.
+    // This must happen immediately, before any async operations.
+    if (requiresSidePanel(requestType) && !isSidebarActive) {
+      openSidePanelSync({
+        tabId: sender.tab.id,
+        windowId,
+        onSuccess: () => {
+          // Process request after panel opens (async operations safe here)
+          handleRequestAsync({ message, sender })
+        },
+        onError: (error, fallbackOpened) => {
+          // Panel failed to open, but fallback might have succeeded
+          logger.error(error, {
+            tags: {
+              file: 'backgroundDappRequests.ts',
+              function: 'initMessageBridge',
+            },
+            extra: {
+              action: 'openSidePanel',
+              fallbackOpened,
+            },
+          })
+
+          // Revalidate sender in error callback context
+          if (!isValidSender(sender)) {
+            logger.error(new Error('Sender tab info unexpectedly invalid in error callback'), {
+              tags: {
+                file: 'backgroundDappRequests.ts',
+                function: 'initMessageBridge',
+              },
+            })
+            return
+          }
+
+          // Queue the message for when panel/popup eventually connects
+          // This works for both side panel and popup window
+          queueMessageForPanel({
+            windowId,
+            message,
+            senderTabInfo: {
+              id: sender.tab.id,
+              url: sender.tab.url,
+              favIconUrl: sender.tab.favIconUrl,
+            },
+          })
+        },
+      })
+    } else {
+      // Non-interactive request or panel already open - async handling is safe
+      handleRequestAsync({ message, sender })
     }
-
-    await handleSidebarRequest({
-      request: message,
-      windowId: sender.tab.windowId,
-      senderTabInfo,
-    })
   })
 
   contentScriptUtilityMessageChannel.addMessageListener(ContentScriptUtilityMessageType.ErrorLog, async (message) => {
@@ -315,10 +368,58 @@ async function handleGetCapabilities({
   }
 }
 
-class ExpectedNoPortError extends Error {
-  constructor() {
-    super('No port in storage to post message to')
+/**
+ * Handles dapp requests asynchronously after the side panel has been opened (if needed).
+ * This function contains the original async logic that was previously in the message listener.
+ * Moving it here allows us to open the side panel synchronously while preserving all existing behavior.
+ */
+async function handleRequestAsync({
+  message,
+  sender,
+}: {
+  message: DappRequest
+  sender: chrome.runtime.MessageSender
+}): Promise<void> {
+  // Revalidate sender
+  if (!isValidSender(sender)) {
+    logger.error(new Error('Invalid sender tab info in handleRequestAsync'), {
+      tags: {
+        file: 'backgroundDappRequests.ts',
+        function: 'handleRequestAsync',
+      },
+      extra: {
+        hasTab: !!sender.tab,
+        hasId: sender.tab?.id !== undefined,
+        hasUrl: !!sender.tab?.url,
+      },
+    })
+    return
+  }
+
+  const senderTabInfo: SenderTabInfo = {
+    id: sender.tab.id,
+    url: sender.tab.url,
+    favIconUrl: sender.tab.favIconUrl,
+  }
+
+  const windowId = sender.tab.windowId
+  const windowIdString = windowId.toString()
+  const isSidebarActive = Boolean(windowIdToSidebarPortMap.get(windowIdString))
+
+  // Try to handle silently if sidebar is not active
+  if (!isSidebarActive) {
+    const handled = await handleSilentBackgroundRequest(message, senderTabInfo)
+    if (handled) {
+      return
+    }
   }
+
+  // Handle via sidebar (queue message for processing)
+  await handleSidebarRequest({
+    request: message,
+    windowId,
+    senderTabInfo,
+  })
 }
 
 async function handleSidebarRequest({
@@ -339,25 +440,111 @@ async function handleSidebarRequest({
     isSidebarClosed: !portChannel,
   }
 
-  try {
-    if (!portChannel) {
-      throw new ExpectedNoPortError()
-    }
-
-    await portChannel.sendMessage(message)
-  } catch (error) {
-    await openSidePanel(senderTabInfo.id, windowId)
-
-    windowIdToPendingRequestsMap.set(windowIdString, windowIdToPendingRequestsMap.get(windowIdString) ?? [])
-    windowIdToPendingRequestsMap.get(windowIdString)?.push(message)
-
-    if (!(error instanceof ExpectedNoPortError)) {
+  if (portChannel) {
+    // Port exists, send message directly
+    try {
+      await portChannel.sendMessage(message)
+    } catch (error) {
       logger.error(error, {
         tags: {
           file: 'backgroundDappRequests.ts',
           function: 'handleSidebarRequest',
         },
       })
+      // Queue message if send fails
+      queueMessageForPanel({ windowId, message: request, senderTabInfo })
     }
+  } else {
+    // IMPORTANT: No port channel means the panel is opening or about to open.
+    // We do NOT call openSidePanel here because it was already opened synchronously
+    // in the message listener to preserve the user gesture context.
+    // Just queue the message - it will be processed when the panel connects.
+    queueMessageForPanel({ windowId, message: request, senderTabInfo })
+  }
+}
+
+/**
+ * Determines if a request requires the side panel to be opened for user interaction
+ */
+function requiresSidePanel(requestType: DappRequestType): boolean {
+  return REQUEST_CLASSIFICATION.interactive.has(requestType)
+}
+
+/**
+ * Validates that the sender has all required tab information
+ */
+function isValidSender(sender?: chrome.runtime.MessageSender): sender is chrome.runtime.MessageSender & {
+  tab: chrome.tabs.Tab & { id: number; url: string }
+} {
+  return sender?.tab?.id !== undefined && sender.tab.url !== undefined
+}
+
+/**
+ * Opens the side panel synchronously to preserve user gesture context.
+ * Must be called within ~1ms of user gesture.
+ * Falls back to opening a popup window if side panel fails.
+ */
+function openSidePanelSync({
+  tabId,
+  windowId,
+  onSuccess,
+  onError,
+}: {
+  tabId: number
+  windowId: number
+  onSuccess: () => void
+  onError: (error: chrome.runtime.LastError, fallbackOpened: boolean) => void
+}): void {
+  chrome.sidePanel.open({ tabId }, () => {
+    const lastError = chrome.runtime.lastError
+    if (lastError) {
+      // Try fallback to popup window - still in sync callback to preserve gesture
+      focusOrCreateDappRequestWindow(tabId, windowId)
+        .then(() => {
+          // Fallback succeeded - notify that we opened a window instead
+          onError(lastError, true)
+        })
+        .catch((fallbackError) => {
+          // Even fallback failed
+          logger.error(fallbackError, {
+            tags: {
+              file: 'backgroundDappRequests.ts',
+              function: 'openSidePanelSync',
+            },
+            extra: { action: 'fallbackToPopupWindow' },
+          })
+          onError(lastError, false)
+        })
+    } else {
+      onSuccess()
+    }
+  })
+}
+
+/**
+ * Queues a message for processing when the side panel connects
+ */
+function queueMessageForPanel({
+  windowId,
+  message,
+  senderTabInfo,
+}: {
+  windowId: number
+  message: DappRequest
+  senderTabInfo: SenderTabInfo
+}): void {
+  const windowIdString = windowId.toString()
+
+  if (!windowIdToPendingRequestsMap.has(windowIdString)) {
+    windowIdToPendingRequestsMap.set(windowIdString, [])
   }
+
+  const queuedMessage: DappRequestMessage = {
+    type: BackgroundToSidePanelRequestType.DappRequestReceived,
+    dappRequest: message,
+    senderTabInfo,
+    isSidebarClosed: true,
+  }
+
+  windowIdToPendingRequestsMap.get(windowIdString)?.push(queuedMessage)
 }

apps/extension/src/background/utils/chromeSidePanelUtils.ts

@@ -6,10 +6,12 @@ import { logger } from 'utilities/src/logger/logger'
 export async function openSidePanel(tabId: number | undefined, windowId: number): Promise<void> {
   let hasError = false
   try {
-    await chrome.sidePanel.open({
-      tabId,
-      windowId,
-    })
+    // Chrome API accepts either tabId or windowId, prefer tabId for specific tab targeting
+    if (tabId !== undefined) {
+      await chrome.sidePanel.open({ tabId })
+    } else {
+      await chrome.sidePanel.open({ windowId })
+    }
   } catch (error) {
     // TODO WALL-4313 - Backup for some broken chrome.sidePanel.open functionality
     // Consider removing this once the issue is resolved or leaving as fallback

packages/uniswap/src/features/transactions/TransactionDetails/UnichainPoweredMessage.tsx

@@ -1,6 +1,7 @@
 import { useTranslation } from 'react-i18next'
 import { Flex, Image, Text } from 'ui/src'
 import { UNICHAIN_LOGO } from 'ui/src/assets'
+import { isInterfaceDesktop } from 'utilities/src/platform'
 
 const UNICHAIN_LOGO_SIZE = 14
 const UNICHAIN_LOGO_BORDER_RADIUS = 4.2
@@ -10,7 +11,7 @@ export function UnichainPoweredMessage({ swappedInTime }: { swappedInTime?: numb
   const { t } = useTranslation()
 
   return (
-    <Flex row centered gap="$spacing6" py="$spacing4" mb="$spacing4">
+    <Flex row centered gap="$spacing6" py="$spacing4" mb={isInterfaceDesktop ? '$spacing8' : '$none'}>
       <Image
         source={UNICHAIN_LOGO}
         width={UNICHAIN_LOGO_SIZE}