Replace 24h absolute auto-lock with configurable idle timer

@shared/api/helpers/extensionMessaging.ts

@@ -71,17 +71,19 @@ export const sendMessageToContentScript = (msg: Msg): Promise<Response> => {
   });
 };
 
-export const sendMessageToBackground = async (msg: Msg): Promise<Response> => {
+export const sendMessageToBackground = async <T = Response>(
+  msg: Msg,
+): Promise<T> => {
   let res;
 
   if (DEV_SERVER) {
     // treat this as an external call because we're making the call from the browser, not the popup
     res = await sendMessageToContentScript(msg);
   } else {
-    res = (await browser.runtime.sendMessage(msg)) as Response;
+    res = await browser.runtime.sendMessage(msg);
   }
 
-  return res as Response;
+  return res as T;
 };
 
 export const FreighterApiNodeError = {

@shared/api/internal.ts

@@ -13,6 +13,10 @@ import {
 } from "stellar-sdk";
 import BigNumber from "bignumber.js";
 import { INDEXER_URL, INDEXER_V2_URL } from "@shared/constants/mercury";
+import {
+  AutoLockTimeoutMinutes,
+  DEFAULT_AUTO_LOCK_TIMEOUT_MINUTES,
+} from "@shared/constants/autoLock";
 import {
   AssetListResponse,
   AssetsListItem,
@@ -60,6 +64,7 @@ import {
   CollectibleContract,
   DiscoverData,
   RecentProtocolEntry,
+  SaveSettingsResponse,
 } from "./types";
 import {
   AccountBalancesInterface,
@@ -1618,47 +1623,51 @@ export const saveSettings = async ({
   isMemoValidationEnabled,
   isHideDustEnabled,
   isOpenSidebarByDefault,
+  autoLockTimeoutMinutes,
 }: {
   activePublicKey: string;
   isDataSharingAllowed: boolean;
   isMemoValidationEnabled: boolean;
   isHideDustEnabled: boolean;
   isOpenSidebarByDefault: boolean;
-}): Promise<Settings & IndexerSettings> => {
-  let response = {
+  autoLockTimeoutMinutes: AutoLockTimeoutMinutes;
+}): Promise<SaveSettingsResponse> => {
+  let response: SaveSettingsResponse = {
     allowList: DEFAULT_ALLOW_LIST,
     isDataSharingAllowed: false,
     networkDetails: MAINNET_NETWORK_DETAILS,
     networksList: DEFAULT_NETWORKS,
     isMemoValidationEnabled: true,
     isRpcHealthy: false,
-    userNotification: { enabled: false, message: "" },
-    settingsState: SettingsState.IDLE,
     isSorobanPublicEnabled: false,
     isNonSSLEnabled: false,
     isHideDustEnabled: true,
     isOpenSidebarByDefault: false,
-    error: "",
-    hiddenAssets: {},
+    autoLockTimeoutMinutes: DEFAULT_AUTO_LOCK_TIMEOUT_MINUTES,
   };
 
   try {
-    response = await sendMessageToBackground({
+    const raw = await sendMessageToBackground<
+      SaveSettingsResponse | { error: string }
+    >({
       activePublicKey,
       isDataSharingAllowed,
       isMemoValidationEnabled,
       isHideDustEnabled,
       isOpenSidebarByDefault,
+      autoLockTimeoutMinutes,
       type: SERVICE_TYPES.SAVE_SETTINGS,
     });
+
+    if ("error" in raw && raw.error) {
+      throw new Error(raw.error);
+    }
+
+    response = raw as SaveSettingsResponse;
   } catch (e) {
     console.error(e);
   }
 
-  if (response.error) {
-    throw new Error(response.error);
-  }
-
   return response;
 };
 
@@ -1863,7 +1872,11 @@ export const loadSettings = (): Promise<
     IndexerSettings &
     ExperimentalFeatures & { assetsLists: AssetsLists }
 > =>
-  sendMessageToBackground({
+  sendMessageToBackground<
+    Settings &
+      IndexerSettings &
+      ExperimentalFeatures & { assetsLists: AssetsLists }
+  >({
     activePublicKey: null,
     type: SERVICE_TYPES.LOAD_SETTINGS,
   });

@shared/api/types/message-request.ts

@@ -11,6 +11,7 @@ import {
   CollectibleKey,
 } from "./types";
 import { AssetsListItem } from "@shared/constants/soroban/asset-list";
+import { AutoLockTimeoutMinutes } from "@shared/constants/autoLock";
 
 export interface TokenToAdd {
   domain: string;
@@ -282,6 +283,11 @@ export interface SaveSettingsMessage extends BaseMessage {
   isMemoValidationEnabled: boolean;
   isDataSharingAllowed: boolean;
   isOpenSidebarByDefault: boolean;
+  autoLockTimeoutMinutes: AutoLockTimeoutMinutes;
+}
+
+export interface UserActivityMessage extends BaseMessage {
+  type: SERVICE_TYPES.USER_ACTIVITY;
 }
 
 export interface SaveExperimentalFeaturesMessage extends BaseMessage {
@@ -547,4 +553,5 @@ export type ServiceMessageRequest =
   | GetHiddenCollectiblesMessage
   | MarkQueueActiveMessage
   | OpenSidebarMessage
-  | RejectSigningRequestMessage;
+  | RejectSigningRequestMessage
+  | UserActivityMessage;

@shared/api/types/types.ts

@@ -13,6 +13,7 @@ import {
   AssetsLists,
   AssetsListItem,
 } from "../../constants/soroban/asset-list";
+import { AutoLockTimeoutMinutes } from "../../constants/autoLock";
 
 export enum ActionStatus {
   IDLE = "IDLE",
@@ -189,6 +190,7 @@ export interface Preferences {
   networksList: NetworkDetails[];
   isHideDustEnabled: boolean;
   isOpenSidebarByDefault: boolean;
+  autoLockTimeoutMinutes: AutoLockTimeoutMinutes;
   error: string;
 }
 
@@ -220,6 +222,20 @@ export interface IndexerSettings {
   userNotification: UserNotification;
 }
 
+export type SaveSettingsResponse = {
+  allowList: AllowList;
+  isDataSharingAllowed: boolean;
+  isMemoValidationEnabled: boolean;
+  networkDetails: NetworkDetails;
+  networksList: NetworkDetails[];
+  isRpcHealthy: boolean;
+  isSorobanPublicEnabled: boolean;
+  isNonSSLEnabled: boolean;
+  isHideDustEnabled: boolean;
+  isOpenSidebarByDefault: boolean;
+  autoLockTimeoutMinutes: AutoLockTimeoutMinutes;
+};
+
 export type Settings = {
   allowList: AllowList;
   networkDetails: NetworkDetails;

@shared/constants/autoLock.ts

@@ -0,0 +1,55 @@
+/**
+ * Single source of truth for the idle auto-lock timeout feature.
+ *
+ * The browser session is locked after this many minutes of user
+ * inactivity across all extension surfaces (popup, sidebar, standalone
+ * signing windows, grant-access windows). Any user interaction inside
+ * an extension page resets the timer.
+ */
+export const VALID_AUTO_LOCK_TIMEOUT_MINUTES = [
+  1, 5, 15, 30, 60, 360, 720, 1440,
+] as const;
+
+export type AutoLockTimeoutMinutes =
+  (typeof VALID_AUTO_LOCK_TIMEOUT_MINUTES)[number];
+
+export const DEFAULT_AUTO_LOCK_TIMEOUT_MINUTES: AutoLockTimeoutMinutes = 720;
+
+export const isValidAutoLockTimeoutMinutes = (
+  value: unknown,
+): value is AutoLockTimeoutMinutes =>
+  typeof value === "number" &&
+  (VALID_AUTO_LOCK_TIMEOUT_MINUTES as readonly number[]).includes(value);
+
+export const coerceAutoLockTimeoutMinutes = (
+  value: unknown,
+): AutoLockTimeoutMinutes =>
+  isValidAutoLockTimeoutMinutes(value)
+    ? value
+    : DEFAULT_AUTO_LOCK_TIMEOUT_MINUTES;
+
+/**
+ * Build a human-readable label for a timeout preset. The English fallback is
+ * constructed in JS and passed to `t()` as `defaultValue`, so even when an
+ * i18n key is missing (common in dev or partial locales) the rendered label is
+ * grammatically correct (e.g. "1 minute" / "5 minutes"). Locales can override
+ * by providing the matching keys.
+ */
+export const formatTimeoutLabel = (
+  minutes: AutoLockTimeoutMinutes,
+  t: (key: string, opts?: Record<string, unknown>) => string,
+): string => {
+  if (minutes >= 60) {
+    const hours = minutes / 60;
+    const fallback = hours === 1 ? "1 hour" : `${hours} hours`;
+    return t("autoLockTimeout.hours", {
+      count: hours,
+      defaultValue: fallback,
+    });
+  }
+  const fallback = minutes === 1 ? "1 minute" : `${minutes} minutes`;
+  return t("autoLockTimeout.minutes", {
+    count: minutes,
+    defaultValue: fallback,
+  });
+};

@shared/constants/services.ts

@@ -70,6 +70,9 @@ export enum SERVICE_TYPES {
   CLEAR_RECENT_PROTOCOLS = "CLEAR_RECENT_PROTOCOLS",
   GET_DISCOVER_WELCOME_SEEN = "GET_DISCOVER_WELCOME_SEEN",
   DISMISS_DISCOVER_WELCOME = "DISMISS_DISCOVER_WELCOME",
+  USER_ACTIVITY = "USER_ACTIVITY",
+  SESSION_LOCKED = "SESSION_LOCKED",
+  SESSION_UNLOCKED = "SESSION_UNLOCKED",
 }
 
 // SIDEBAR_NAVIGATE is a plain string constant (not in an enum) because it is

extension/src/background/__tests__/initAlarmListener.test.ts

@@ -0,0 +1,86 @@
+import browser from "webextension-polyfill";
+
+import { SERVICE_TYPES } from "@shared/constants/services";
+
+let alarmHandler:
+  | ((alarm: { name: string }) => void | Promise<void>)
+  | undefined;
+
+const mockSendMessage = jest.fn().mockResolvedValue(undefined);
+
+jest.mock("webextension-polyfill", () => ({
+  alarms: {
+    onAlarm: {
+      addListener: jest.fn((handler) => {
+        alarmHandler = handler;
+      }),
+    },
+  },
+  runtime: {
+    sendMessage: (...args: any[]) => mockSendMessage(...args),
+  },
+}));
+
+const mockClearSession = jest.fn().mockResolvedValue(undefined);
+jest.mock("background/helpers/session", () => {
+  const actual = jest.requireActual("background/helpers/session");
+  return {
+    ...actual,
+    clearSession: (...args: any[]) => mockClearSession(...args),
+  };
+});
+
+jest.mock("background/store", () => ({
+  buildStore: jest.fn().mockResolvedValue({}),
+}));
+
+jest.mock("background/helpers/dataStorageAccess", () => ({
+  dataStorageAccess: jest.fn().mockReturnValue({}),
+  browserLocalStorage: {},
+}));
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { initAlarmListener } = require("background/index");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { SESSION_ALARM_NAME } = require("background/helpers/session");
+
+describe("initAlarmListener", () => {
+  beforeEach(() => {
+    mockSendMessage.mockClear();
+    mockClearSession.mockClear();
+    alarmHandler = undefined;
+    initAlarmListener();
+  });
+
+  it("clears the session and broadcasts SESSION_LOCKED when the auto-lock alarm fires", async () => {
+    expect(browser.alarms.onAlarm.addListener).toHaveBeenCalled();
+    expect(alarmHandler).toBeDefined();
+
+    await alarmHandler!({ name: SESSION_ALARM_NAME });
+
+    expect(mockClearSession).toHaveBeenCalledTimes(1);
+    expect(mockSendMessage).toHaveBeenCalledTimes(1);
+    expect(mockSendMessage).toHaveBeenCalledWith({
+      type: SERVICE_TYPES.SESSION_LOCKED,
+    });
+  });
+
+  it("swallows sendMessage errors when no UI is open to receive the broadcast", async () => {
+    mockSendMessage.mockRejectedValueOnce(
+      new Error("Could not establish connection. Receiving end does not exist."),
+    );
+
+    await expect(
+      alarmHandler!({ name: SESSION_ALARM_NAME }),
+    ).resolves.toBeUndefined();
+
+    expect(mockClearSession).toHaveBeenCalledTimes(1);
+  });
+
+  it("ignores unrelated alarms", async () => {
+    await alarmHandler!({ name: "some-other-alarm" });
+
+    expect(mockClearSession).not.toHaveBeenCalled();
+    expect(mockSendMessage).not.toHaveBeenCalled();
+  });
+});