release: lace-extension@2.0.4 (#2219)

Snapshot of input-output-hk/lace-platform @ 994a962152aa6027bd735eb61424fb8334bdbcf2
Produced by open-source-release-publish.yml.

See PROVENANCE for the allowlist hash that controlled this snapshot.

Co-authored-by: lace-publish-bot <lace-publish-bot@users.noreply.github.com>

Author: lace-releases[bot]

PROVENANCE

@@ -1,10 +1,10 @@
 Lace public source snapshot
 ===========================
 
-release-tag:         lace-extension@2.0.3
+release-tag:         lace-extension@2.0.4
 source-repo:         input-output-hk/lace-platform (private)
-source-commit:       adb23f654599f926f0f3a57abbe6cd8306364b6b
-snapshot-utc:        2026-05-06T20:56:53.464Z
+source-commit:       994a962152aa6027bd735eb61424fb8334bdbcf2
+snapshot-utc:        2026-05-08T19:54:36.790Z
 
 allowlist-sha256:    a75a43e9e238d609b21b9d7f3409fa46bb8a0a92a4738dbeba71076ec4e74929
 excludelist-sha256:  8e7916a357aae4f8a8a963e32cb48392e039572670b390f043322a9d17e98a50

apps/lace-extension/app.json

@@ -4,7 +4,7 @@
     "slug": "lace-extension",
     "owner": "lace_io",
     "newArchEnabled": true,
-    "version": "2.0.3",
+    "version": "2.0.4",
     "orientation": "portrait",
     "icon": "./assets/icon.png",
     "platforms": ["web"],

apps/lace-extension/assets/manifest.json

@@ -1,7 +1,7 @@
 {
   "name": "$EXTENSION_NAME",
   "description": "One fast, accessible, and secure platform for digital assets, DApps, NFTs, and DeFi.",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "manifest_version": 3,
   "key": "$EXTENSION_KEY",
   "icons": {

apps/lace-extension/src/ExpoApp.tsx

@@ -13,7 +13,7 @@ import {
   NoOpProvider,
   createSentryProvider,
 } from '@lace-lib/observability';
-import { Loader, configureImageFormat } from '@lace-lib/ui-toolkit';
+import { Splash, configureImageFormat } from '@lace-lib/ui-toolkit';
 import * as Sentry from '@sentry/react';
 import React, { useEffect, useState } from 'react';
 import { Provider } from 'react-redux';
@@ -133,7 +133,7 @@ const ExpoApp = () => {
     void loadPromise.then(setInit);
   }, []);
 
-  if (!init) return <Loader />;
+  if (!init) return <Splash />;
 
   const appContent = (
     <Provider store={init.store}>
@@ -143,7 +143,7 @@ const ExpoApp = () => {
 
   // Only wrap with Sentry ErrorBoundary if Sentry is initialized
   const wrappedContent = isSentryEnabled ? (
-    <Sentry.ErrorBoundary fallback={<Loader />}>
+    <Sentry.ErrorBoundary fallback={<Splash />}>
       {appContent}
     </Sentry.ErrorBoundary>
   ) : (

apps/lace-extension/src/sw-script/action-click-handler.ts

@@ -0,0 +1,51 @@
+// Pure logic for the SW's chrome.action.onClicked handler. Extracted so the
+// branches can be unit-tested without booting the SW.
+//
+// The `sidePanel` permission is declared as required in manifest.json, so
+// either:
+//   - the host browser recognises it and auto-grants it at install time
+//     (Chrome / Edge / Brave / Arc, …) — `chrome.sidePanel` is callable; or
+//   - the host browser silently ignores the unknown permission name
+//     (older Chromium forks, e.g. Yandex) — `chrome.sidePanel` is undefined.
+// We branch on the runtime presence of the API, not on a permission probe.
+
+import type { DefaultOpenMode } from '@lace-contract/views';
+
+export type ActionClickHandlerDeps = {
+  // Runtime check for `chrome.sidePanel`. False on hosts that don't ship the
+  // API (older Chromium forks).
+  isSidePanelApiAvailable: () => boolean;
+  // The user's persisted mode preference. The slice forces 'tab' when the
+  // API is unavailable; we still gate on `isSidePanelApiAvailable` here as
+  // defence in depth.
+  getStoredDefaultOpenMode: () => DefaultOpenMode;
+  openLaceTab: () => Promise<void>;
+  openSidePanel: (windowId: number) => Promise<void>;
+  logger: { error: (...args: unknown[]) => void };
+};
+
+/**
+ * Routes a toolbar-action click:
+ *   - host doesn't ship sidePanel, or user chose tab → open a tab.
+ *   - otherwise → open the side panel; on failure, fall back to a tab.
+ */
+export const handleActionClick = async (
+  deps: ActionClickHandlerDeps,
+  tab: { windowId?: number },
+): Promise<void> => {
+  const shouldOpenSidePanel =
+    deps.isSidePanelApiAvailable() &&
+    deps.getStoredDefaultOpenMode() === 'sidePanel';
+
+  if (!shouldOpenSidePanel || tab.windowId === undefined) {
+    await deps.openLaceTab();
+    return;
+  }
+
+  try {
+    await deps.openSidePanel(tab.windowId);
+  } catch (error) {
+    deps.logger.error('Failed to open side panel imperatively', error);
+    await deps.openLaceTab();
+  }
+};

apps/lace-extension/src/sw-script/load.ts

@@ -3,14 +3,102 @@ import {
   createStore,
   findStorageModule,
 } from '@lace-contract/module';
+import {
+  applySidePanelBehavior,
+  DEFAULT_OPEN_MODE,
+  isSidePanelApiAvailable,
+} from '@lace-contract/views';
 import { devToolsEnhancer } from '@redux-devtools/remote';
 
-import { createExtensionModuleLoader, ENV, logger } from '../util';
+import {
+  createExtensionModuleLoader,
+  ENV,
+  logger,
+  readDefaultOpenMode,
+} from '../util';
 
+import { handleActionClick } from './action-click-handler';
 import { createRemoteStore } from './create-remote-store';
 import { exposeAPIs } from './expose-apis';
 
 import type { FeatureFlagApi } from '../util';
+import type { DefaultOpenMode } from '@lace-contract/views';
+
+// MV3 only dispatches events to listeners registered before the SW script
+// hits its first await. If `chrome.action.onClicked.addListener` is registered
+// after an await, the click that woke the SW is dropped — the user has to
+// click again once boot finishes. Everything in this top section therefore
+// runs synchronously, before the awaits below.
+
+// In-memory mirror of the persisted preference, refreshed from
+// chrome.storage.local on every click and at SW boot. Initialised to the
+// contract's default so the first click after boot has *some* value to use
+// if the storage read somehow fails. See ADR 26.
+//
+// We deliberately do NOT subscribe to chrome.storage.onChanged here: that
+// listener would fire on every chrome.storage.local write (including
+// redux-persist's), resetting the SW idle timer and preventing it from going
+// dormant. The popup updates Chrome's setPanelBehavior itself after writing,
+// so cross-context propagation does not require an SW listener.
+const cachedDefaultOpenMode: { current: DefaultOpenMode } = {
+  current: DEFAULT_OPEN_MODE,
+};
+
+const openLaceTab = async () => {
+  try {
+    const indexUrl = chrome.runtime.getURL('expo/index.html');
+    const existing = await chrome.tabs.query({ url: `${indexUrl}*` });
+    if (existing[0]?.id !== undefined) {
+      await chrome.tabs.update(existing[0].id, { active: true });
+      if (existing[0].windowId !== undefined) {
+        await chrome.windows.update(existing[0].windowId, { focused: true });
+      }
+      return;
+    }
+    await chrome.tabs.create({ url: 'expo/index.html', active: true });
+  } catch (error) {
+    logger.error('Failed to open Lace tab', error);
+  }
+};
+
+const refreshFromStorage = async (): Promise<DefaultOpenMode> => {
+  const mode = await readDefaultOpenMode();
+  cachedDefaultOpenMode.current = mode;
+  // Fire-and-forget: handleActionClick decides what to open by reading
+  // cachedDefaultOpenMode (just assigned above), not Chrome's setPanelBehavior
+  // state, so the click can be handled before this Promise settles.
+  applySidePanelBehavior(mode)?.catch((error: unknown) => {
+    logger.error('Failed to update side panel behavior', error);
+  });
+  return mode;
+};
+
+// Kick off the initial read synchronously so Chrome's setPanelBehavior is
+// reconciled at boot (in case the popup was unable to update it the last
+// time the user changed mode).
+void refreshFromStorage().catch((error: unknown) => {
+  logger.error('Failed to read defaultOpenMode from storage', error);
+});
+
+chrome.action.onClicked.addListener(tab => {
+  void (async () => {
+    // Re-read on every click so popup-side changes propagate without a
+    // chrome.storage.onChanged subscription (which would keep the SW alive).
+    // The await preserves the user-gesture window — chrome.storage reads
+    // typically resolve in well under a millisecond.
+    await refreshFromStorage().catch(() => cachedDefaultOpenMode.current);
+    await handleActionClick(
+      {
+        isSidePanelApiAvailable,
+        getStoredDefaultOpenMode: () => cachedDefaultOpenMode.current,
+        openLaceTab,
+        openSidePanel: async windowId => chrome.sidePanel.open({ windowId }),
+        logger,
+      },
+      tab,
+    );
+  })();
+});
 
 const {
   loadModules,
@@ -45,8 +133,6 @@ const { store } = await createStore(
 );
 const remoteStore = createRemoteStore(store);
 
-void chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true });
-
 const featureFlags: FeatureFlagApi = {
   getFeatureFlags: async () => loadedFeatureFlags,
 };

apps/lace-extension/src/util/default-open-mode-storage.ts

@@ -0,0 +1,36 @@
+// SW-side reader for the toolbar action's open-mode preference. The MV3
+// service worker cannot read redux-persist before its first await, so this
+// preference lives in chrome.storage.local — see ADR 26. Both the SW and
+// the views-extension UI hook talk to chrome.storage.local through the
+// same key.
+//
+// The SW deliberately does NOT register a chrome.storage.onChanged listener
+// here. That listener fires on every chrome.storage.local write, which in
+// Lace includes redux-persist writes — each event resets the SW idle timer
+// and prevents the service worker from going dormant. The popup applies the
+// new chrome.sidePanel behaviour itself after writing, and the SW reconciles
+// the cached value on the next click.
+
+import {
+  DEFAULT_OPEN_MODE,
+  DEFAULT_OPEN_MODE_STORAGE_KEY,
+  isValidDefaultOpenMode,
+} from '@lace-contract/views';
+
+import type { DefaultOpenMode } from '@lace-contract/views';
+
+type ChromeStorageArea = {
+  get: (key: string) => Promise<Record<string, unknown>>;
+};
+type ChromeLike = { storage?: { local?: ChromeStorageArea } };
+
+const getLocal = (): ChromeStorageArea | undefined =>
+  (globalThis as { chrome?: ChromeLike }).chrome?.storage?.local;
+
+export const readDefaultOpenMode = async (): Promise<DefaultOpenMode> => {
+  const local = getLocal();
+  if (!local) return DEFAULT_OPEN_MODE;
+  const result = await local.get(DEFAULT_OPEN_MODE_STORAGE_KEY);
+  const value = result[DEFAULT_OPEN_MODE_STORAGE_KEY];
+  return isValidDefaultOpenMode(value) ? value : DEFAULT_OPEN_MODE;
+};

apps/lace-extension/src/util/index.ts

@@ -6,3 +6,4 @@ export * from './config';
 export * from './connect-store';
 export * from './load-modules';
 export * from './all-modules';
+export * from './default-open-mode-storage';

apps/lace-extension/test/sw-script/action-click-handler.test.ts

@@ -0,0 +1,108 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { handleActionClick } from '../../src/sw-script/action-click-handler';
+
+import type { ActionClickHandlerDeps } from '../../src/sw-script/action-click-handler';
+
+const noopLogger = { error: vi.fn() };
+
+const createDeps = (
+  overrides: Partial<ActionClickHandlerDeps> = {},
+): ActionClickHandlerDeps => ({
+  isSidePanelApiAvailable: () => true,
+  getStoredDefaultOpenMode: () => 'sidePanel',
+  openLaceTab: vi.fn(async () => {}),
+  openSidePanel: vi.fn(async () => {}),
+  logger: noopLogger,
+  ...overrides,
+});
+
+describe('handleActionClick', () => {
+  beforeEach(() => {
+    noopLogger.error.mockClear();
+  });
+
+  it('opens a tab when the host does not ship chrome.sidePanel (e.g. Yandex)', async () => {
+    const openLaceTab = vi.fn(async () => {});
+    const openSidePanel = vi.fn(async () => {});
+    const deps = createDeps({
+      isSidePanelApiAvailable: () => false,
+      // Even if stored mode is 'sidePanel' (the default), no API → tab.
+      getStoredDefaultOpenMode: () => 'sidePanel',
+      openLaceTab,
+      openSidePanel,
+    });
+
+    await handleActionClick(deps, { windowId: 1 });
+
+    expect(openLaceTab).toHaveBeenCalledTimes(1);
+    expect(openSidePanel).not.toHaveBeenCalled();
+  });
+
+  it("opens a tab when the user has chosen 'tab' mode", async () => {
+    const openLaceTab = vi.fn(async () => {});
+    const openSidePanel = vi.fn(async () => {});
+    const deps = createDeps({
+      isSidePanelApiAvailable: () => true,
+      getStoredDefaultOpenMode: () => 'tab',
+      openLaceTab,
+      openSidePanel,
+    });
+
+    await handleActionClick(deps, { windowId: 2 });
+
+    expect(openLaceTab).toHaveBeenCalledTimes(1);
+    expect(openSidePanel).not.toHaveBeenCalled();
+  });
+
+  it('opens the side panel imperatively when API is available, mode is sidePanel, and a windowId is provided', async () => {
+    const openLaceTab = vi.fn(async () => {});
+    const openSidePanel = vi.fn(async () => {});
+    const deps = createDeps({
+      isSidePanelApiAvailable: () => true,
+      getStoredDefaultOpenMode: () => 'sidePanel',
+      openLaceTab,
+      openSidePanel,
+    });
+
+    await handleActionClick(deps, { windowId: 7 });
+
+    expect(openSidePanel).toHaveBeenCalledWith(7);
+    expect(openLaceTab).not.toHaveBeenCalled();
+  });
+
+  it('falls back to a tab when openSidePanel throws', async () => {
+    const openLaceTab = vi.fn(async () => {});
+    const openSidePanel = vi.fn(async () => {
+      throw new Error('boom');
+    });
+    const deps = createDeps({
+      isSidePanelApiAvailable: () => true,
+      getStoredDefaultOpenMode: () => 'sidePanel',
+      openLaceTab,
+      openSidePanel,
+    });
+
+    await handleActionClick(deps, { windowId: 7 });
+
+    expect(openSidePanel).toHaveBeenCalledWith(7);
+    expect(openLaceTab).toHaveBeenCalledTimes(1);
+    expect(noopLogger.error).toHaveBeenCalled();
+  });
+
+  it('falls back to a tab when no windowId is available', async () => {
+    const openLaceTab = vi.fn(async () => {});
+    const openSidePanel = vi.fn(async () => {});
+    const deps = createDeps({
+      isSidePanelApiAvailable: () => true,
+      getStoredDefaultOpenMode: () => 'sidePanel',
+      openLaceTab,
+      openSidePanel,
+    });
+
+    await handleActionClick(deps, { windowId: undefined });
+
+    expect(openSidePanel).not.toHaveBeenCalled();
+    expect(openLaceTab).toHaveBeenCalledTimes(1);
+  });
+});