From aa34e303d317a36440a89dfe1efffe0f8ff3ff59 Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Wed, 19 Feb 2025 17:43:28 +0100
Subject: [PATCH 01/12] feat: move reducers into seperate common package,
 create shared state for mobile

---
 suite-common/bluetooth/package.json           |  17 ++
 .../bluetooth/src/bluetoothActions.ts         |  64 ++++++++
 .../bluetooth/src/bluetoothReducer.ts         | 148 ++++++++++++++++++
 .../bluetooth/src/bluetoothSelectors.ts       |  35 +++++
 suite-common/bluetooth/src/index.ts           |  24 +++
 suite-common/bluetooth/tsconfig.json          |   9 ++
 6 files changed, 297 insertions(+)
 create mode 100644 suite-common/bluetooth/package.json
 create mode 100644 suite-common/bluetooth/src/bluetoothActions.ts
 create mode 100644 suite-common/bluetooth/src/bluetoothReducer.ts
 create mode 100644 suite-common/bluetooth/src/bluetoothSelectors.ts
 create mode 100644 suite-common/bluetooth/src/index.ts
 create mode 100644 suite-common/bluetooth/tsconfig.json

diff --git a/suite-common/bluetooth/package.json b/suite-common/bluetooth/package.json
new file mode 100644
index 00000000000..78accc4a9b8
--- /dev/null
+++ b/suite-common/bluetooth/package.json
@@ -0,0 +1,17 @@
+{
+    "name": "@suite-common/bluetooth",
+    "version": "1.0.0",
+    "private": true,
+    "license": "See LICENSE.md in repo root",
+    "sideEffects": false,
+    "main": "src/index",
+    "scripts": {
+        "depcheck": "yarn g:depcheck",
+        "type-check": "yarn g:tsc --build"
+    },
+    "dependencies": {
+        "@reduxjs/toolkit": "1.9.5",
+        "@suite-common/redux-utils": "workspace:*",
+        "@suite-common/wallet-core": "workspace:*"
+    }
+}
diff --git a/suite-common/bluetooth/src/bluetoothActions.ts b/suite-common/bluetooth/src/bluetoothActions.ts
new file mode 100644
index 00000000000..d7593fa3465
--- /dev/null
+++ b/suite-common/bluetooth/src/bluetoothActions.ts
@@ -0,0 +1,64 @@
+import { createAction } from '@reduxjs/toolkit';
+
+import {
+    BluetoothDeviceCommon,
+    BluetoothScanStatus,
+    DeviceBluetoothStatus,
+} from './bluetoothReducer';
+
+export const BLUETOOTH_PREFIX = '@suite/bluetooth';
+
+export const bluetoothAdapterEventAction = createAction(
+    `${BLUETOOTH_PREFIX}/adapter-event`,
+    ({ isPowered }: { isPowered: boolean }) => ({ payload: { isPowered } }),
+);
+
+type BluetoothNearbyDevicesUpdateActionPayload = {
+    nearbyDevices: BluetoothDeviceCommon[];
+};
+
+export const bluetoothNearbyDevicesUpdateAction = createAction(
+    `${BLUETOOTH_PREFIX}/nearby-devices-update`,
+    ({ nearbyDevices }: BluetoothNearbyDevicesUpdateActionPayload) => ({
+        payload: { nearbyDevices },
+    }),
+);
+
+type BluetoothKnownDevicesUpdateActionPayload = {
+    knownDevices: BluetoothDeviceCommon[];
+};
+
+export const bluetoothKnownDevicesUpdateAction = createAction(
+    `${BLUETOOTH_PREFIX}/known-devices-update`,
+    ({ knownDevices }: BluetoothKnownDevicesUpdateActionPayload) => ({
+        payload: { knownDevices },
+    }),
+);
+
+export const bluetoothRemoveKnownDeviceAction = createAction(
+    `${BLUETOOTH_PREFIX}/remove-known-device`,
+    ({ id }: { id: string }) => ({
+        payload: { id },
+    }),
+);
+
+export const bluetoothConnectDeviceEventAction = createAction(
+    `${BLUETOOTH_PREFIX}/connect-device-event`,
+    ({ connectionStatus, id }: { id: string; connectionStatus: DeviceBluetoothStatus }) => ({
+        payload: { id, connectionStatus },
+    }),
+);
+
+export const bluetoothScanStatusAction = createAction(
+    `${BLUETOOTH_PREFIX}/scan-status`,
+    ({ status }: { status: BluetoothScanStatus }) => ({ payload: { status } }),
+);
+
+export const allBluetoothActions = {
+    bluetoothAdapterEventAction,
+    bluetoothNearbyDevicesUpdateAction,
+    bluetoothConnectDeviceEventAction,
+    bluetoothScanStatusAction,
+    bluetoothKnownDevicesUpdateAction,
+    bluetoothRemoveKnownDeviceAction,
+};
diff --git a/suite-common/bluetooth/src/bluetoothReducer.ts b/suite-common/bluetooth/src/bluetoothReducer.ts
new file mode 100644
index 00000000000..40a53e85b03
--- /dev/null
+++ b/suite-common/bluetooth/src/bluetoothReducer.ts
@@ -0,0 +1,148 @@
+import { AnyAction, Draft } from '@reduxjs/toolkit';
+
+import { createReducerWithExtraDeps } from '@suite-common/redux-utils';
+import { deviceActions } from '@suite-common/wallet-core';
+
+import {
+    bluetoothAdapterEventAction,
+    bluetoothConnectDeviceEventAction,
+    bluetoothKnownDevicesUpdateAction,
+    bluetoothNearbyDevicesUpdateAction,
+    bluetoothRemoveKnownDeviceAction,
+    bluetoothScanStatusAction,
+} from './bluetoothActions';
+
+export type BluetoothScanStatus = 'idle' | 'running' | 'error';
+
+export type DeviceBluetoothStatus =
+    | { type: 'pairing'; pin?: string }
+    | { type: 'paired' }
+    | { type: 'connecting' }
+    | { type: 'connected' }
+    | {
+          type: 'error';
+          error: string;
+      };
+
+// Do not export this outside of this suite-common package, Suite uses ist own type
+// from the '@trezor/transport-bluetooth' and mobile (native) have its own type as well.
+export type BluetoothDeviceCommon = {
+    id: string;
+    name: string;
+    data: number[]; // Todo: consider typed data-structure for this
+    lastUpdatedTimestamp: number;
+};
+
+export type DeviceBluetoothStatusType = DeviceBluetoothStatus['type'];
+
+export type BluetoothState<T extends BluetoothDeviceCommon> = {
+    adapterStatus: 'unknown' | 'enabled' | 'disabled';
+    scanStatus: BluetoothScanStatus;
+    nearbyDevices: Array<{ device: T; status: DeviceBluetoothStatus | null }>;
+
+    // This will be persisted, those are devices we believed that are paired
+    // (because we already successfully paired them in the Suite) in the Operating System
+    knownDevices: T[];
+};
+
+export type BluetoothDeviceState<T extends BluetoothDeviceCommon> = {
+    device: T;
+    status: DeviceBluetoothStatus | null;
+};
+
+export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>() => {
+    const initialState: BluetoothState<T> = {
+        adapterStatus: 'unknown',
+        scanStatus: 'idle',
+        nearbyDevices: [] as BluetoothDeviceState<T>[],
+        knownDevices: [] as T[],
+    };
+
+    return createReducerWithExtraDeps<BluetoothState<T>>(initialState, (builder, extra) =>
+        builder
+            .addCase(bluetoothAdapterEventAction, (state, { payload: { isPowered } }) => {
+                state.adapterStatus = isPowered ? 'enabled' : 'disabled';
+                if (!isPowered) {
+                    state.nearbyDevices = [];
+                    state.scanStatus = 'idle';
+                }
+            })
+            .addCase(
+                bluetoothNearbyDevicesUpdateAction,
+                (state, { payload: { nearbyDevices } }) => {
+                    state.nearbyDevices = nearbyDevices
+                        .sort((a, b) => a.lastUpdatedTimestamp - b.lastUpdatedTimestamp)
+                        .map(
+                            (device): Draft<BluetoothDeviceState<T>> => ({
+                                device: device as Draft<T>,
+                                status: null,
+                            }),
+                        );
+                },
+            )
+            .addCase(
+                bluetoothConnectDeviceEventAction,
+                (state, { payload: { id, connectionStatus } }) => {
+                    const device = state.nearbyDevices.find(it => it.device.id === id);
+
+                    if (device !== undefined) {
+                        device.status = connectionStatus;
+                    }
+                },
+            )
+            .addCase(bluetoothKnownDevicesUpdateAction, (state, { payload: { knownDevices } }) => {
+                state.knownDevices = knownDevices as Draft<T>[];
+            })
+            .addCase(bluetoothRemoveKnownDeviceAction, (state, { payload: { id } }) => {
+                state.knownDevices = state.knownDevices.filter(
+                    knownDevice => knownDevice.id !== id,
+                );
+            })
+            .addCase(bluetoothScanStatusAction, (state, { payload: { status } }) => {
+                state.scanStatus = status;
+            })
+            .addCase(deviceActions.deviceDisconnect, (state, { payload: { bluetoothProps } }) => {
+                if (bluetoothProps !== undefined) {
+                    state.nearbyDevices = state.nearbyDevices.filter(
+                        it => it.device.id !== bluetoothProps.id,
+                    );
+                }
+            })
+            .addCase(
+                deviceActions.connectDevice,
+                (
+                    state,
+                    {
+                        payload: {
+                            device: { bluetoothProps },
+                        },
+                    },
+                ) => {
+                    if (bluetoothProps === undefined) {
+                        return;
+                    }
+
+                    const deviceState = state.nearbyDevices.find(
+                        it => it.device.id === bluetoothProps.id,
+                    );
+
+                    if (deviceState !== undefined) {
+                        // Once device is fully connected, we save it to the list of known devices
+                        // so next time user opens suite we can automatically connect to it.
+                        const foundKnownDevice = state.knownDevices.find(
+                            it => it.id === bluetoothProps.id,
+                        );
+                        if (foundKnownDevice === undefined) {
+                            state.knownDevices.push(deviceState.device);
+                        }
+                    }
+                },
+            )
+            .addMatcher(
+                action => action.type === extra.actionTypes.storageLoad,
+                (state, action: AnyAction) => {
+                    state.knownDevices = action.payload.knownDevices?.bluetooth ?? [];
+                },
+            ),
+    );
+};
diff --git a/suite-common/bluetooth/src/bluetoothSelectors.ts b/suite-common/bluetooth/src/bluetoothSelectors.ts
new file mode 100644
index 00000000000..dcd7d07a3e7
--- /dev/null
+++ b/suite-common/bluetooth/src/bluetoothSelectors.ts
@@ -0,0 +1,35 @@
+import { createWeakMapSelector } from '@suite-common/redux-utils';
+
+import { BluetoothDeviceCommon, BluetoothDeviceState, BluetoothState } from './bluetoothReducer';
+
+type State<T extends BluetoothDeviceCommon> = {
+    bluetooth: BluetoothState<T>;
+};
+
+export const selectAdapterStatus = <T extends BluetoothDeviceCommon>(state: State<T>) =>
+    state.bluetooth.adapterStatus;
+
+export const selectKnownDevices = <T extends BluetoothDeviceCommon>(state: State<T>) =>
+    state.bluetooth.knownDevices;
+
+export const prepareSelectAllDevices = <T extends BluetoothDeviceCommon>() =>
+    createWeakMapSelector.withTypes<State<T>>()(
+        [state => state.bluetooth.nearbyDevices, state => state.bluetooth.knownDevices],
+        (nearbyDevices, knownDevices) => {
+            const map = new Map<string, BluetoothDeviceState<T>>();
+            knownDevices.forEach(knownDevice => {
+                map.set(knownDevice.id, { device: knownDevice, status: null });
+            });
+
+            nearbyDevices.forEach(nearbyDevice => {
+                if (!map.has(nearbyDevice.device.id)) {
+                    map.set(nearbyDevice.device.id, nearbyDevice);
+                }
+            });
+
+            return Array.from(map.values());
+        },
+    );
+
+export const selectScanStatus = <T extends BluetoothDeviceCommon>(state: State<T>) =>
+    state.bluetooth.scanStatus;
diff --git a/suite-common/bluetooth/src/index.ts b/suite-common/bluetooth/src/index.ts
new file mode 100644
index 00000000000..dfb4615599e
--- /dev/null
+++ b/suite-common/bluetooth/src/index.ts
@@ -0,0 +1,24 @@
+export {
+    bluetoothAdapterEventAction,
+    BLUETOOTH_PREFIX,
+    allBluetoothActions,
+    bluetoothConnectDeviceEventAction,
+    bluetoothNearbyDevicesUpdateAction,
+    bluetoothKnownDevicesUpdateAction,
+    bluetoothRemoveKnownDeviceAction,
+    bluetoothScanStatusAction,
+} from './bluetoothActions';
+
+export { prepareBluetoothReducerCreator } from './bluetoothReducer';
+export type {
+    BluetoothDeviceState,
+    BluetoothScanStatus,
+    DeviceBluetoothStatusType,
+} from './bluetoothReducer';
+
+export {
+    prepareSelectAllDevices,
+    selectKnownDevices,
+    selectAdapterStatus,
+    selectScanStatus,
+} from './bluetoothSelectors';
diff --git a/suite-common/bluetooth/tsconfig.json b/suite-common/bluetooth/tsconfig.json
new file mode 100644
index 00000000000..73c744e02f0
--- /dev/null
+++ b/suite-common/bluetooth/tsconfig.json
@@ -0,0 +1,9 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": { "outDir": "libDev" },
+    "references": [
+        { "path": "../redux-utils" },
+        { "path": "../suite-types" },
+        { "path": "../wallet-core" }
+    ]
+}

From c0009aaa20c76ad027160e3d9a4f86710f28989a Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Wed, 19 Feb 2025 17:43:38 +0100
Subject: [PATCH 02/12] feat: implement suite-common bluetooth code into Suite

---
 .../src/actions/bluetooth/bluetoothActions.ts |  39 -----
 .../bluetooth/bluetoothConnectDeviceThunk.ts  |   3 +-
 .../bluetooth/bluetoothStartScanningThunk.ts  |   6 +-
 .../bluetooth/bluetoothStopScanningThunk.ts   |   6 +-
 .../actions/bluetooth/initBluetoothThunk.ts   |  40 +++--
 .../suite/src/actions/suite/storageActions.ts |   4 +-
 .../suite/bluetooth/BluetoothConnect.tsx      |  59 +++----
 ...evice.tsx => BluetoothDeviceComponent.tsx} |   6 +-
 .../suite/bluetooth/BluetoothDeviceItem.tsx   |   4 +-
 .../suite/bluetooth/BluetoothDeviceList.tsx   |   5 +-
 .../suite/bluetooth/BluetoothPairingPin.tsx   |   8 +-
 .../suite/bluetooth/BluetoothScanFooter.tsx   |   4 +-
 .../bluetooth/BluetoothSelectedDevice.tsx     |  19 +--
 .../middlewares/wallet/storageMiddleware.ts   |   6 +-
 .../reducers/bluetooth/bluetoothReducer.ts    | 146 ------------------
 .../reducers/bluetooth/bluetoothSelectors.ts  |   7 -
 packages/suite/src/reducers/store.ts          |   4 +-
 packages/suite/src/types/suite/index.ts       |   2 +-
 .../SettingsDevice/BluetoothEraseBonds.tsx    |   9 +-
 yarn.lock                                     |  10 ++
 20 files changed, 115 insertions(+), 272 deletions(-)
 delete mode 100644 packages/suite/src/actions/bluetooth/bluetoothActions.ts
 rename packages/suite/src/components/suite/bluetooth/{BluetoothDevice.tsx => BluetoothDeviceComponent.tsx} (89%)
 delete mode 100644 packages/suite/src/reducers/bluetooth/bluetoothReducer.ts
 delete mode 100644 packages/suite/src/reducers/bluetooth/bluetoothSelectors.ts

diff --git a/packages/suite/src/actions/bluetooth/bluetoothActions.ts b/packages/suite/src/actions/bluetooth/bluetoothActions.ts
deleted file mode 100644
index 94457659b17..00000000000
--- a/packages/suite/src/actions/bluetooth/bluetoothActions.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { createAction } from '@reduxjs/toolkit';
-
-import { BluetoothDevice } from '@trezor/transport-bluetooth';
-
-import {
-    BluetoothScanStatus,
-    DeviceBluetoothStatus,
-} from '../../reducers/bluetooth/bluetoothReducer';
-
-export const BLUETOOTH_PREFIX = '@suite/bluetooth';
-
-export const bluetoothAdapterEventAction = createAction(
-    `${BLUETOOTH_PREFIX}/adapter-event`,
-    ({ isPowered }: { isPowered: boolean }) => ({ payload: { isPowered } }),
-);
-
-export const bluetoothDeviceListUpdate = createAction(
-    `${BLUETOOTH_PREFIX}/device-list-update`,
-    ({ devices }: { devices: BluetoothDevice[] }) => ({ payload: { devices } }),
-);
-
-export const bluetoothConnectDeviceEventAction = createAction(
-    `${BLUETOOTH_PREFIX}/device-connection-status`,
-    ({ connectionStatus, id }: { id: string; connectionStatus: DeviceBluetoothStatus }) => ({
-        payload: { id, connectionStatus },
-    }),
-);
-
-export const bluetoothScanStatusAction = createAction(
-    `${BLUETOOTH_PREFIX}/scan-status`,
-    ({ status }: { status: BluetoothScanStatus }) => ({ payload: { status } }),
-);
-
-export const allBluetoothActions = {
-    bluetoothAdapterEventAction,
-    bluetoothDeviceListUpdate,
-    bluetoothConnectDeviceEventAction,
-    bluetoothScanStatusAction,
-};
diff --git a/packages/suite/src/actions/bluetooth/bluetoothConnectDeviceThunk.ts b/packages/suite/src/actions/bluetooth/bluetoothConnectDeviceThunk.ts
index b5bd33d7d3f..6ca9a7b847c 100644
--- a/packages/suite/src/actions/bluetooth/bluetoothConnectDeviceThunk.ts
+++ b/packages/suite/src/actions/bluetooth/bluetoothConnectDeviceThunk.ts
@@ -1,8 +1,7 @@
+import { BLUETOOTH_PREFIX } from '@suite-common/bluetooth';
 import { createThunk } from '@suite-common/redux-utils';
 import { bluetoothIpc } from '@trezor/transport-bluetooth';
 
-import { BLUETOOTH_PREFIX } from './bluetoothActions';
-
 type ThunkResponse = ReturnType<typeof bluetoothIpc.connectDevice>;
 
 export const bluetoothConnectDeviceThunk = createThunk<ThunkResponse, { id: string }, void>(
diff --git a/packages/suite/src/actions/bluetooth/bluetoothStartScanningThunk.ts b/packages/suite/src/actions/bluetooth/bluetoothStartScanningThunk.ts
index a1a389033df..90af08320ea 100644
--- a/packages/suite/src/actions/bluetooth/bluetoothStartScanningThunk.ts
+++ b/packages/suite/src/actions/bluetooth/bluetoothStartScanningThunk.ts
@@ -1,11 +1,11 @@
+import { BLUETOOTH_PREFIX, bluetoothScanStatusAction } from '@suite-common/bluetooth';
 import { createThunk } from '@suite-common/redux-utils';
 import { bluetoothIpc } from '@trezor/transport-bluetooth';
 
-import { BLUETOOTH_PREFIX } from './bluetoothActions';
-
 export const bluetoothStartScanningThunk = createThunk<void, void, void>(
     `${BLUETOOTH_PREFIX}/bluetoothStartScanningThunk`,
-    _ => {
+    (_, { dispatch }) => {
+        dispatch(bluetoothScanStatusAction({ status: 'running' }));
         // This can fail, but if there is an error we already got it from `adapter-event`
         // and user is informed about it (bluetooth turned-off, ...)
         bluetoothIpc.startScan();
diff --git a/packages/suite/src/actions/bluetooth/bluetoothStopScanningThunk.ts b/packages/suite/src/actions/bluetooth/bluetoothStopScanningThunk.ts
index 086f3a21959..445c92db5e9 100644
--- a/packages/suite/src/actions/bluetooth/bluetoothStopScanningThunk.ts
+++ b/packages/suite/src/actions/bluetooth/bluetoothStopScanningThunk.ts
@@ -1,11 +1,11 @@
+import { BLUETOOTH_PREFIX, bluetoothScanStatusAction } from '@suite-common/bluetooth';
 import { createThunk } from '@suite-common/redux-utils';
 import { bluetoothIpc } from '@trezor/transport-bluetooth';
 
-import { BLUETOOTH_PREFIX } from './bluetoothActions';
-
 export const bluetoothStopScanningThunk = createThunk<void, void, void>(
     `${BLUETOOTH_PREFIX}/bluetoothStopScanningThunk`,
-    _ => {
+    (_, { dispatch }) => {
+        dispatch(bluetoothScanStatusAction({ status: 'idle' }));
         // This can fail, but there is nothing we can do about it
         bluetoothIpc.stopScan();
     },
diff --git a/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts b/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts
index 05512b97dcc..74b242988c5 100644
--- a/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts
+++ b/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts
@@ -1,13 +1,15 @@
-import { createThunk } from '@suite-common/redux-utils/';
-import { DeviceConnectionStatus, bluetoothIpc } from '@trezor/transport-bluetooth';
-import { Without } from '@trezor/type-utils';
-
 import {
     BLUETOOTH_PREFIX,
     bluetoothAdapterEventAction,
     bluetoothConnectDeviceEventAction,
-    bluetoothDeviceListUpdate,
-} from './bluetoothActions';
+    bluetoothKnownDevicesUpdateAction,
+    bluetoothNearbyDevicesUpdateAction,
+    selectKnownDevices,
+} from '@suite-common/bluetooth';
+import { createThunk } from '@suite-common/redux-utils/';
+import { BluetoothDevice, DeviceConnectionStatus, bluetoothIpc } from '@trezor/transport-bluetooth';
+import { Without } from '@trezor/type-utils';
+
 import { selectSuiteFlags } from '../../reducers/suite/suiteReducer';
 
 type DeviceConnectionStatusWithOptionalId = Without<DeviceConnectionStatus, 'id'> & {
@@ -28,9 +30,27 @@ export const initBluetoothThunk = createThunk<void, void, void>(
             dispatch(bluetoothAdapterEventAction({ isPowered }));
         });
 
-        bluetoothIpc.on('device-list-update', devices => {
-            console.warn('device-list-update', devices);
-            dispatch(bluetoothDeviceListUpdate({ devices }));
+        bluetoothIpc.on('device-list-update', nearbyDevices => {
+            console.warn('device-list-update', nearbyDevices);
+
+            const knownDevices = selectKnownDevices<BluetoothDevice>(getState());
+
+            console.log('nearbyDevices', nearbyDevices);
+
+            // update pairedDevices, id is changed after pairing (linux)
+            const remappedKnownDevices = knownDevices.map(knownDevice => {
+                // find devices with the same address but different id
+                const changed = nearbyDevices.find(
+                    nearbyDevice =>
+                        nearbyDevice.address === knownDevice.address &&
+                        nearbyDevice.id !== knownDevice.id,
+                );
+
+                return changed ? { ...knownDevice, id: changed.id } : knownDevice;
+            });
+
+            dispatch(bluetoothKnownDevicesUpdateAction({ knownDevices: remappedKnownDevices }));
+            dispatch(bluetoothNearbyDevicesUpdateAction({ nearbyDevices }));
         });
 
         bluetoothIpc.on('device-connection-status', connectionStatus => {
@@ -49,7 +69,7 @@ export const initBluetoothThunk = createThunk<void, void, void>(
         });
 
         // TODO: this should be called after trezor/connect init?
-        const knownDevices = getState().bluetooth.pairedDevices;
+        const knownDevices = selectKnownDevices<BluetoothDevice>(getState());
         await bluetoothIpc.init({ knownDevices });
     },
 );
diff --git a/packages/suite/src/actions/suite/storageActions.ts b/packages/suite/src/actions/suite/storageActions.ts
index 1ec655fb545..85d641a29fe 100644
--- a/packages/suite/src/actions/suite/storageActions.ts
+++ b/packages/suite/src/actions/suite/storageActions.ts
@@ -104,8 +104,8 @@ export const saveCoinjoinDebugSettings = () => async (_dispatch: Dispatch, getSt
 
 export const saveKnownDevices = () => async (_dispatch: Dispatch, getState: GetState) => {
     if (!(await db.isAccessible())) return;
-    const { pairedDevices } = getState().bluetooth;
-    db.addItem('knownDevices', { bluetooth: pairedDevices }, 'devices', true);
+    const { knownDevices } = getState().bluetooth;
+    db.addItem('knownDevices', { bluetooth: knownDevices }, 'devices', true);
 };
 
 export const saveFormDraft = async (key: string, draft: FieldValues) => {
diff --git a/packages/suite/src/components/suite/bluetooth/BluetoothConnect.tsx b/packages/suite/src/components/suite/bluetooth/BluetoothConnect.tsx
index de9f0f7fa69..85d567312e8 100644
--- a/packages/suite/src/components/suite/bluetooth/BluetoothConnect.tsx
+++ b/packages/suite/src/components/suite/bluetooth/BluetoothConnect.tsx
@@ -1,9 +1,16 @@
 import { useCallback, useEffect, useState } from 'react';
 
+import {
+    bluetoothConnectDeviceEventAction,
+    bluetoothScanStatusAction,
+    prepareSelectAllDevices,
+    selectAdapterStatus,
+    selectScanStatus,
+} from '@suite-common/bluetooth';
 import { notificationsActions } from '@suite-common/toast-notifications';
 import { Card, Column, ElevationUp } from '@trezor/components';
-import TrezorConnect from '@trezor/connect';
 import { spacings } from '@trezor/theme';
+import { BluetoothDevice } from '@trezor/transport-bluetooth';
 import { TimerId } from '@trezor/type-utils';
 
 import { BluetoothDeviceList } from './BluetoothDeviceList';
@@ -14,19 +21,10 @@ import { BluetoothSelectedDevice } from './BluetoothSelectedDevice';
 import { BluetoothTips } from './BluetoothTips';
 import { BluetoothNotEnabled } from './errors/BluetoothNotEnabled';
 import { BluetoothVersionNotCompatible } from './errors/BluetoothVersionNotCompatible';
-import {
-    bluetoothConnectDeviceEventAction,
-    bluetoothScanStatusAction,
-} from '../../../actions/bluetooth/bluetoothActions';
 import { bluetoothConnectDeviceThunk } from '../../../actions/bluetooth/bluetoothConnectDeviceThunk';
 import { bluetoothStartScanningThunk } from '../../../actions/bluetooth/bluetoothStartScanningThunk';
 import { bluetoothStopScanningThunk } from '../../../actions/bluetooth/bluetoothStopScanningThunk';
 import { useDispatch, useSelector } from '../../../hooks/suite';
-import {
-    selectBluetoothDeviceList,
-    selectBluetoothEnabled,
-    selectBluetoothScanStatus,
-} from '../../../reducers/bluetooth/bluetoothSelectors';
 
 const SCAN_TIMEOUT = 30_000;
 
@@ -35,17 +33,21 @@ type BluetoothConnectProps = {
     uiMode: 'spatial' | 'card';
 };
 
+const selectAllDevices = prepareSelectAllDevices<BluetoothDevice>();
+
 export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) => {
     const dispatch = useDispatch();
     const [selectedDeviceId, setSelectedDeviceId] = useState<string | null>(null);
     const [scannerTimerId, setScannerTimerId] = useState<TimerId | null>(null);
 
-    const isBluetoothEnabled = useSelector(selectBluetoothEnabled);
-    const scanStatus = useSelector(selectBluetoothScanStatus);
-    const deviceList = useSelector(selectBluetoothDeviceList);
-    const devices = Object.values(deviceList);
+    const bluetoothAdapterStatus = useSelector(selectAdapterStatus);
+    const scanStatus = useSelector(selectScanStatus);
+    const devices = useSelector(selectAllDevices);
 
-    const selectedDevice = selectedDeviceId !== null ? deviceList[selectedDeviceId] ?? null : null;
+    const selectedDevice =
+        selectedDeviceId !== null
+            ? devices.find(device => device.device.id === selectedDeviceId)
+            : undefined;
 
     useEffect(() => {
         dispatch(bluetoothStartScanningThunk());
@@ -64,7 +66,7 @@ export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) =>
     useEffect(() => {
         // Intentionally no `clearScamTimer`, this is first run and if we use this we would create infinite re-render
         const timerId = setTimeout(() => {
-            dispatch(bluetoothScanStatusAction({ status: 'done' }));
+            dispatch(bluetoothScanStatusAction({ status: 'idle' }));
         }, SCAN_TIMEOUT);
 
         setScannerTimerId(timerId);
@@ -76,14 +78,13 @@ export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) =>
 
         clearScamTimer();
         const timerId = setTimeout(() => {
-            dispatch(bluetoothScanStatusAction({ status: 'done' }));
+            dispatch(bluetoothScanStatusAction({ status: 'idle' }));
         }, SCAN_TIMEOUT);
         setScannerTimerId(timerId);
     };
 
     const onSelect = async (id: string) => {
         setSelectedDeviceId(id);
-
         const result = await dispatch(bluetoothConnectDeviceThunk({ id })).unwrap();
 
         if (!result.success) {
@@ -100,27 +101,16 @@ export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) =>
                 }),
             );
         } else {
-            // Todo: What to do with error in this flow? UI-Wise
-
             dispatch(
                 bluetoothConnectDeviceEventAction({
                     id,
                     connectionStatus: { type: 'connected' },
                 }),
             );
-
-            // WAIT for connect event, TODO: figure out better way
-            const closePopupAfterConnection = () => {
-                TrezorConnect.off('device-connect', closePopupAfterConnection);
-                TrezorConnect.off('device-connect_unacquired', closePopupAfterConnection);
-                // setSelectedDeviceStatus({ type: 'error', id }); // Todo: what here?
-            };
-            TrezorConnect.on('device-connect', closePopupAfterConnection);
-            TrezorConnect.on('device-connect_unacquired', closePopupAfterConnection);
         }
     };
 
-    if (!isBluetoothEnabled) {
+    if (bluetoothAdapterStatus === 'disabled') {
         return <BluetoothNotEnabled onCancel={onClose} />;
     }
 
@@ -133,8 +123,8 @@ export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) =>
     console.log('selectedDevice', selectedDevice);
 
     // This is fake, we scan for devices all the time
-    const isScanning = scanStatus !== 'done';
-    const scanFailed = devices.length === 0 && scanStatus === 'done';
+    const isScanning = scanStatus === 'running';
+    const scanFailed = devices.length === 0 && scanStatus === 'idle';
 
     const handlePairingCancel = () => {
         setSelectedDeviceId(null);
@@ -142,7 +132,8 @@ export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) =>
     };
 
     if (
-        selectedDevice !== null &&
+        selectedDevice !== undefined &&
+        selectedDevice.status !== null &&
         selectedDevice.status.type === 'pairing' &&
         (selectedDevice.status.pin?.length ?? 0) > 0
     ) {
@@ -155,7 +146,7 @@ export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) =>
         );
     }
 
-    if (selectedDevice !== null) {
+    if (selectedDevice !== undefined) {
         return <BluetoothSelectedDevice device={selectedDevice} onReScanClick={onReScanClick} />;
     }
 
diff --git a/packages/suite/src/components/suite/bluetooth/BluetoothDevice.tsx b/packages/suite/src/components/suite/bluetooth/BluetoothDeviceComponent.tsx
similarity index 89%
rename from packages/suite/src/components/suite/bluetooth/BluetoothDevice.tsx
rename to packages/suite/src/components/suite/bluetooth/BluetoothDeviceComponent.tsx
index 5d093829364..91c9e0319cc 100644
--- a/packages/suite/src/components/suite/bluetooth/BluetoothDevice.tsx
+++ b/packages/suite/src/components/suite/bluetooth/BluetoothDeviceComponent.tsx
@@ -3,10 +3,10 @@ import { DeviceModelInternal } from '@trezor/connect';
 import { models } from '@trezor/connect/src/data/models'; // Todo: solve this import issue
 import { RotateDeviceImage } from '@trezor/product-components';
 import { spacings } from '@trezor/theme';
-import { BluetoothDevice as BluetoothDeviceType } from '@trezor/transport-bluetooth';
+import { BluetoothDevice } from '@trezor/transport-bluetooth';
 
 type BluetoothDeviceProps = {
-    device: BluetoothDeviceType;
+    device: BluetoothDevice;
     flex?: FlexProps['flex'];
     margin?: FlexProps['margin'];
 };
@@ -18,7 +18,7 @@ const getModelEnumFromBytesUtil = (_id: number) => DeviceModelInternal.T3W1;
 // discuss final format of it
 const getColorEnumFromVariantBytesUtil = (variant: number) => variant;
 
-export const BluetoothDevice = ({ device, flex, margin }: BluetoothDeviceProps) => {
+export const BluetoothDeviceComponent = ({ device, flex, margin }: BluetoothDeviceProps) => {
     const model = getModelEnumFromBytesUtil(device.data[2]);
     const color = getColorEnumFromVariantBytesUtil(device.data[1]);
     const colorName = models[model].colors[color.toString()];
diff --git a/packages/suite/src/components/suite/bluetooth/BluetoothDeviceItem.tsx b/packages/suite/src/components/suite/bluetooth/BluetoothDeviceItem.tsx
index e1234e1394b..082fabdac1f 100644
--- a/packages/suite/src/components/suite/bluetooth/BluetoothDeviceItem.tsx
+++ b/packages/suite/src/components/suite/bluetooth/BluetoothDeviceItem.tsx
@@ -2,7 +2,7 @@ import { Button, Row } from '@trezor/components';
 import { spacings } from '@trezor/theme';
 import { BluetoothDevice as BluetoothDeviceType } from '@trezor/transport-bluetooth';
 
-import { BluetoothDevice } from './BluetoothDevice';
+import { BluetoothDeviceComponent } from './BluetoothDeviceComponent';
 
 type BluetoothDeviceItemProps = {
     device: BluetoothDeviceType;
@@ -12,7 +12,7 @@ type BluetoothDeviceItemProps = {
 
 export const BluetoothDeviceItem = ({ device, onClick, isDisabled }: BluetoothDeviceItemProps) => (
     <Row onClick={onClick} gap={spacings.md} alignItems="stretch">
-        <BluetoothDevice device={device} flex="1" />
+        <BluetoothDeviceComponent device={device} flex="1" />
         <Button
             variant="primary"
             size="small"
diff --git a/packages/suite/src/components/suite/bluetooth/BluetoothDeviceList.tsx b/packages/suite/src/components/suite/bluetooth/BluetoothDeviceList.tsx
index 7c4256736bb..e185ebb7fed 100644
--- a/packages/suite/src/components/suite/bluetooth/BluetoothDeviceList.tsx
+++ b/packages/suite/src/components/suite/bluetooth/BluetoothDeviceList.tsx
@@ -1,11 +1,12 @@
+import { BluetoothDeviceState } from '@suite-common/bluetooth';
 import { Card, Column, Row, SkeletonRectangle } from '@trezor/components';
 import { spacings } from '@trezor/theme';
+import { BluetoothDevice } from '@trezor/transport-bluetooth';
 
 import { BluetoothDeviceItem } from './BluetoothDeviceItem';
-import { BluetoothDeviceState } from '../../../reducers/bluetooth/bluetoothReducer';
 
 type BluetoothDeviceListProps = {
-    deviceList: BluetoothDeviceState[];
+    deviceList: BluetoothDeviceState<BluetoothDevice>[];
     onSelect: (id: string) => void;
     isScanning: boolean;
     isDisabled: boolean;
diff --git a/packages/suite/src/components/suite/bluetooth/BluetoothPairingPin.tsx b/packages/suite/src/components/suite/bluetooth/BluetoothPairingPin.tsx
index 231dff0f1a5..bde3bb69c16 100644
--- a/packages/suite/src/components/suite/bluetooth/BluetoothPairingPin.tsx
+++ b/packages/suite/src/components/suite/bluetooth/BluetoothPairingPin.tsx
@@ -2,9 +2,9 @@ import styled from 'styled-components';
 
 import { Card, Link, NewModal, Row, Text } from '@trezor/components';
 import { spacings, spacingsPx, typography } from '@trezor/theme';
-import { BluetoothDevice as BluetoothDeviceType } from '@trezor/transport-bluetooth';
+import { BluetoothDevice } from '@trezor/transport-bluetooth';
 
-import { BluetoothDevice } from './BluetoothDevice';
+import { BluetoothDeviceComponent } from './BluetoothDeviceComponent';
 
 const Pin = styled.div`
     display: flex;
@@ -18,7 +18,7 @@ const Pin = styled.div`
 type BluetoothPairingPinProps = {
     onCancel: () => void;
     pairingPin?: string;
-    device: BluetoothDeviceType;
+    device: BluetoothDevice;
 };
 
 export const BluetoothPairingPin = ({ onCancel, pairingPin, device }: BluetoothPairingPinProps) => (
@@ -40,7 +40,7 @@ export const BluetoothPairingPin = ({ onCancel, pairingPin, device }: BluetoothP
                 margin={{ vertical: spacings.xxl, horizontal: spacings.xxl }}
             >
                 <Pin>{pairingPin}</Pin>
-                <BluetoothDevice
+                <BluetoothDeviceComponent
                     device={device}
                     margin={{ vertical: spacings.xxs, horizontal: spacings.xxs }}
                 />
diff --git a/packages/suite/src/components/suite/bluetooth/BluetoothScanFooter.tsx b/packages/suite/src/components/suite/bluetooth/BluetoothScanFooter.tsx
index 5e333d0938b..1403b0640f2 100644
--- a/packages/suite/src/components/suite/bluetooth/BluetoothScanFooter.tsx
+++ b/packages/suite/src/components/suite/bluetooth/BluetoothScanFooter.tsx
@@ -1,8 +1,8 @@
+import { BluetoothScanStatus } from '@suite-common/bluetooth';
 import { Text } from '@trezor/components';
 import { spacings } from '@trezor/theme';
 
 import { NotTrezorYouAreLookingFor } from './NotTrezorYouAreLookingFor';
-import { BluetoothScanStatus } from '../../../reducers/bluetooth/bluetoothReducer';
 
 type BluetoothScanFooterProps = {
     onReScanClick: () => void;
@@ -23,7 +23,7 @@ export const BluetoothScanFooter = ({
         );
     }
 
-    if (scanStatus === 'done' && numberOfDevices > 0) {
+    if (scanStatus === 'idle' && numberOfDevices > 0) {
         return <NotTrezorYouAreLookingFor onReScanClick={onReScanClick} />;
     }
 
diff --git a/packages/suite/src/components/suite/bluetooth/BluetoothSelectedDevice.tsx b/packages/suite/src/components/suite/bluetooth/BluetoothSelectedDevice.tsx
index 8e2cd1c4666..333c0fe9f06 100644
--- a/packages/suite/src/components/suite/bluetooth/BluetoothSelectedDevice.tsx
+++ b/packages/suite/src/components/suite/bluetooth/BluetoothSelectedDevice.tsx
@@ -1,9 +1,10 @@
+import { BluetoothDeviceState } from '@suite-common/bluetooth';
 import { Card, ElevationContext, Icon, Row, Spinner, Text } from '@trezor/components';
 import { spacings } from '@trezor/theme';
+import { BluetoothDevice } from '@trezor/transport-bluetooth';
 
-import { BluetoothDevice } from './BluetoothDevice';
+import { BluetoothDeviceComponent } from './BluetoothDeviceComponent';
 import { BluetoothTips } from './BluetoothTips';
-import { BluetoothDeviceState } from '../../../reducers/bluetooth/bluetoothReducer';
 
 const PairedComponent = () => (
     <Row gap={spacings.xs} alignItems="center">
@@ -21,24 +22,24 @@ const PairingComponent = () => (
 );
 
 export type OkComponentProps = {
-    device: BluetoothDeviceState;
+    device: BluetoothDeviceState<BluetoothDevice>;
 };
 
 const OkComponent = ({ device }: OkComponentProps) => (
     <Row gap={spacings.md} alignItems="center" justifyContent="stretch">
-        <BluetoothDevice device={device.device} flex="1" />
+        <BluetoothDeviceComponent device={device.device} flex="1" />
 
-        {device.status.type === 'connected' ? <PairedComponent /> : <PairingComponent />}
+        {device?.status?.type === 'connected' ? <PairedComponent /> : <PairingComponent />}
     </Row>
 );
 
 export type ErrorComponentProps = {
-    device: BluetoothDeviceState;
+    device: BluetoothDeviceState<BluetoothDevice>;
     onReScanClick: () => void;
 };
 
 const ErrorComponent = ({ device, onReScanClick }: ErrorComponentProps) => {
-    if (device.status.type !== 'error') {
+    if (device?.status?.type !== 'error') {
         return null;
     }
 
@@ -46,7 +47,7 @@ const ErrorComponent = ({ device, onReScanClick }: ErrorComponentProps) => {
 };
 
 export type BluetoothSelectedDeviceProps = {
-    device: BluetoothDeviceState;
+    device: BluetoothDeviceState<BluetoothDevice>;
     onReScanClick: () => void;
 };
 
@@ -55,7 +56,7 @@ export const BluetoothSelectedDevice = ({
     onReScanClick,
 }: BluetoothSelectedDeviceProps) => (
     <ElevationContext baseElevation={0}>
-        {device.status.type === 'error' ? (
+        {device?.status?.type === 'error' ? (
             <ErrorComponent onReScanClick={onReScanClick} device={device} />
         ) : (
             <Card>
diff --git a/packages/suite/src/middlewares/wallet/storageMiddleware.ts b/packages/suite/src/middlewares/wallet/storageMiddleware.ts
index 3391c814c78..e554d79f1ad 100644
--- a/packages/suite/src/middlewares/wallet/storageMiddleware.ts
+++ b/packages/suite/src/middlewares/wallet/storageMiddleware.ts
@@ -2,6 +2,7 @@ import { isAnyOf } from '@reduxjs/toolkit';
 import { MiddlewareAPI } from 'redux';
 
 import { analyticsActions } from '@suite-common/analytics';
+import { bluetoothKnownDevicesUpdateAction } from '@suite-common/bluetooth';
 import { messageSystemActions } from '@suite-common/message-system';
 import { isDeviceRemembered } from '@suite-common/suite-utils';
 import { TokenManagementAction } from '@suite-common/token-definitions';
@@ -202,7 +203,10 @@ const storageMiddleware = (api: MiddlewareAPI<Dispatch, AppState>) => {
                 }
             }
 
-            if (deviceActions.connectDevice.match(action)) {
+            if (
+                deviceActions.connectDevice.match(action) ||
+                bluetoothKnownDevicesUpdateAction.match(action)
+            ) {
                 api.dispatch(storageActions.saveKnownDevices());
             }
 
diff --git a/packages/suite/src/reducers/bluetooth/bluetoothReducer.ts b/packages/suite/src/reducers/bluetooth/bluetoothReducer.ts
deleted file mode 100644
index 9a28d13a8e9..00000000000
--- a/packages/suite/src/reducers/bluetooth/bluetoothReducer.ts
+++ /dev/null
@@ -1,146 +0,0 @@
-import { createReducer } from '@reduxjs/toolkit';
-
-import { deviceActions } from '@suite-common/wallet-core';
-import { BluetoothDevice, DeviceConnectionStatus } from '@trezor/transport-bluetooth';
-import { Without } from '@trezor/type-utils/';
-
-import {
-    bluetoothAdapterEventAction,
-    bluetoothConnectDeviceEventAction,
-    bluetoothDeviceListUpdate,
-    bluetoothScanStatusAction,
-} from '../../actions/bluetooth/bluetoothActions';
-import { bluetoothStartScanningThunk } from '../../actions/bluetooth/bluetoothStartScanningThunk';
-import { bluetoothStopScanningThunk } from '../../actions/bluetooth/bluetoothStopScanningThunk';
-
-export type BluetoothScanStatus = 'running' | 'done';
-
-export type DeviceBluetoothStatus =
-    | Without<DeviceConnectionStatus, 'id'> // We have id in the deviceList map in the state
-    | {
-          type: 'error';
-          error: string;
-      }
-    | {
-          // This is state when device is fully connected and dashboard is shown to the user
-          // At this point we can save the device to the list of paired devices for future reconnects
-          type: 'connect-connected'; // Todo: Find better naming
-      };
-
-export type DeviceBluetoothStatusType = DeviceBluetoothStatus['type'];
-
-export type BluetoothDeviceState = {
-    device: BluetoothDevice;
-    status: DeviceBluetoothStatus;
-};
-
-type BluetoothState = {
-    isBluetoothEnabled: boolean;
-    scanStatus: BluetoothScanStatus;
-
-    // This will be persisted, those are devices we believed that are paired
-    // (because we already successfully paired them in the Suite) in the Operating System
-    pairedDevices: BluetoothDevice[];
-
-    // This list of devices that is union of saved-devices and device that we get from scan
-    deviceList: Record<string, BluetoothDeviceState>;
-};
-
-const initialState: BluetoothState = {
-    isBluetoothEnabled: true, // To prevent the UI from flickering when the page is loaded
-    scanStatus: 'running', // To prevent the UI from flickering when the page is loaded
-    pairedDevices: [],
-    deviceList: {},
-};
-
-export const bluetoothReducer = createReducer(initialState, builder =>
-    builder
-        .addCase('@storage/load', (state, rest) => {
-            // @ts-expect-error typed action
-            state.pairedDevices = rest.payload.knownDevices?.bluetooth || [];
-        })
-        .addCase(bluetoothAdapterEventAction, (state, { payload: { isPowered } }) => {
-            state.isBluetoothEnabled = isPowered;
-            if (!isPowered) {
-                state.deviceList = {};
-            }
-        })
-        .addCase(bluetoothDeviceListUpdate, (state, { payload: { devices } }) => {
-            // update pairedDevices, id is changed after pairing (linux)
-            state.pairedDevices = state.pairedDevices.reduce((prev, curr) => {
-                // find devices with the same address but different id
-                const changed = devices.find(d => d.address === curr.address && d.id !== curr.id);
-                prev.push(changed ? { ...curr, id: changed.id } : curr);
-
-                return prev;
-            }, [] as BluetoothDevice[]);
-
-            const newList: Record<string, BluetoothDeviceState> = Object.fromEntries(
-                state.pairedDevices.map(device => [
-                    device.id,
-                    {
-                        device,
-                        status: { type: 'paired' },
-                    },
-                ]),
-            );
-
-            devices.forEach(device => {
-                newList[device.id] = {
-                    device,
-                    status: state.deviceList[device.id]?.status ?? { type: 'found' },
-                };
-            });
-
-            state.deviceList = newList;
-        })
-        .addCase(
-            bluetoothConnectDeviceEventAction,
-            (state, { payload: { id, connectionStatus } }) => {
-                const device = state.deviceList[id];
-
-                if (device !== undefined) {
-                    device.status = connectionStatus;
-                }
-            },
-        )
-        .addCase(bluetoothScanStatusAction, (state, { payload: { status } }) => {
-            state.scanStatus = status;
-        })
-        .addCase(deviceActions.deviceDisconnect, (state, { payload: { bluetoothProps } }) => {
-            if (bluetoothProps) {
-                delete state.deviceList[bluetoothProps.id];
-            }
-        })
-        .addCase(
-            deviceActions.connectDevice,
-            (
-                state,
-                {
-                    payload: {
-                        device: { bluetoothProps },
-                    },
-                },
-            ) => {
-                if (bluetoothProps && bluetoothProps.id in state.deviceList) {
-                    const deviceState = state.deviceList[bluetoothProps.id];
-                    deviceState.status = { type: 'connect-connected' };
-
-                    // Once device is fully connected, we save it to the list of paired devices
-                    // so next time user opens suite
-                    const foundPairedDevice = state.pairedDevices.find(
-                        it => it.id === bluetoothProps.id,
-                    );
-                    if (foundPairedDevice === undefined) {
-                        state.pairedDevices.push(deviceState.device);
-                    }
-                }
-            },
-        )
-        .addCase(bluetoothStartScanningThunk.fulfilled, state => {
-            state.scanStatus = 'running';
-        })
-        .addCase(bluetoothStopScanningThunk.fulfilled, state => {
-            state.scanStatus = 'done';
-        }),
-);
diff --git a/packages/suite/src/reducers/bluetooth/bluetoothSelectors.ts b/packages/suite/src/reducers/bluetooth/bluetoothSelectors.ts
deleted file mode 100644
index 97672c10ebf..00000000000
--- a/packages/suite/src/reducers/bluetooth/bluetoothSelectors.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { AppState } from '../store';
-
-export const selectBluetoothEnabled = (state: AppState) => state.bluetooth.isBluetoothEnabled;
-
-export const selectBluetoothDeviceList = (state: AppState) => state.bluetooth.deviceList;
-
-export const selectBluetoothScanStatus = (state: AppState) => state.bluetooth.scanStatus;
diff --git a/packages/suite/src/reducers/store.ts b/packages/suite/src/reducers/store.ts
index 10c113f8929..0b376f934f2 100644
--- a/packages/suite/src/reducers/store.ts
+++ b/packages/suite/src/reducers/store.ts
@@ -10,6 +10,7 @@ import { isCodesignBuild } from '@trezor/env-utils';
 import { mergeDeepObject } from '@trezor/utils';
 import { prepareTokenDefinitionsReducer } from '@suite-common/token-definitions';
 import { prepareFirmwareReducer } from '@suite-common/firmware';
+import { prepareBluetoothReducerCreator } from '@suite-common/bluetooth';
 import { accountsActions } from '@suite-common/wallet-core';
 
 import suiteMiddlewares from 'src/middlewares/suite';
@@ -22,7 +23,6 @@ import walletReducers from 'src/reducers/wallet';
 import onboardingReducers from 'src/reducers/onboarding';
 import recoveryReducers from 'src/reducers/recovery';
 import backupReducers from 'src/reducers/backup';
-import { bluetoothReducer } from 'src/reducers/bluetooth/bluetoothReducer';
 // toastMiddleware can be used only in suite-desktop and suite-web
 // it's not included into `@suite-middlewares` index
 import toastMiddleware from 'src/middlewares/suite/toastMiddleware';
@@ -30,9 +30,11 @@ import type { PreloadStoreAction } from 'src/support/suite/preloadStore';
 
 import { desktopReducer } from './desktop';
 import { extraDependencies } from '../support/extraDependencies';
+import { BluetoothDevice } from '@trezor/transport-bluetooth';
 
 const firmwareReducer = prepareFirmwareReducer(extraDependencies);
 const tokenDefinitionsReducer = prepareTokenDefinitionsReducer(extraDependencies);
+const bluetoothReducer = prepareBluetoothReducerCreator<BluetoothDevice>()(extraDependencies);
 
 const rootReducer = combineReducers({
     ...suiteReducers,
diff --git a/packages/suite/src/types/suite/index.ts b/packages/suite/src/types/suite/index.ts
index 44d8d1533a7..b63d2dc67e5 100644
--- a/packages/suite/src/types/suite/index.ts
+++ b/packages/suite/src/types/suite/index.ts
@@ -2,6 +2,7 @@ import type { Store as ReduxStore } from 'redux';
 import type { ThunkAction as TAction, ThunkDispatch } from 'redux-thunk';
 
 import { analyticsActions } from '@suite-common/analytics';
+import { allBluetoothActions } from '@suite-common/bluetooth';
 import { deviceAuthenticityActions } from '@suite-common/device-authenticity';
 import { firmwareActions } from '@suite-common/firmware';
 import { messageSystemActions } from '@suite-common/message-system';
@@ -11,7 +12,6 @@ import { deviceActions, discoveryActions, transactionsActions } from '@suite-com
 import type { BlockchainEvent, TransportEvent, UiEvent } from '@trezor/connect';
 
 import type { BackupAction } from 'src/actions/backup/backupActions';
-import { allBluetoothActions } from 'src/actions/bluetooth/bluetoothActions';
 import type { OnboardingAction } from 'src/actions/onboarding/onboardingActions';
 import type { RecoveryAction } from 'src/actions/recovery/recoveryActions';
 import type { WalletSettingsAction } from 'src/actions/settings/walletSettingsActions';
diff --git a/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx b/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx
index bc4572cd97e..469dae32936 100644
--- a/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx
+++ b/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx
@@ -1,12 +1,14 @@
 import { useState } from 'react';
 
+import { bluetoothRemoveKnownDeviceAction } from '@suite-common/bluetooth';
 import { Button } from '@trezor/components';
 import TrezorConnect from '@trezor/connect';
 
 import { ActionColumn, SectionItem, TextColumn } from 'src/components/suite';
-import { useSelector } from 'src/hooks/suite';
+import { useDispatch, useSelector } from 'src/hooks/suite';
 
 export const BluetoothEraseBonds = () => {
+    const dispatch = useDispatch();
     const device = useSelector(state => state.device.selectedDevice);
 
     const [inProgress, setInProgress] = useState(false);
@@ -15,6 +17,11 @@ export const BluetoothEraseBonds = () => {
         setInProgress(true);
         // TODO: missing button request in FW
         const result = await TrezorConnect.eraseBonds({ device });
+
+        if (device?.bluetoothProps?.id !== undefined) {
+            dispatch(bluetoothRemoveKnownDeviceAction({ id: device.bluetoothProps.id }));
+        }
+
         console.warn('Erase bonds!', result);
         setInProgress(false);
     };
diff --git a/yarn.lock b/yarn.lock
index 75a46007774..fb4d036b0d8 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9604,6 +9604,16 @@ __metadata:
   languageName: unknown
   linkType: soft
 
+"@suite-common/bluetooth@workspace:suite-common/bluetooth":
+  version: 0.0.0-use.local
+  resolution: "@suite-common/bluetooth@workspace:suite-common/bluetooth"
+  dependencies:
+    "@reduxjs/toolkit": "npm:1.9.5"
+    "@suite-common/redux-utils": "workspace:*"
+    "@suite-common/wallet-core": "workspace:*"
+  languageName: unknown
+  linkType: soft
+
 "@suite-common/connect-init@workspace:*, @suite-common/connect-init@workspace:suite-common/connect-init":
   version: 0.0.0-use.local
   resolution: "@suite-common/connect-init@workspace:suite-common/connect-init"

From e1e8026d629bc6ffcd2a1a177a30f13e96959b18 Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Thu, 20 Feb 2025 12:32:31 +0100
Subject: [PATCH 03/12] feat: add tests for bluetoothRedcer and
 devicesSecondTime

---
 suite-common/bluetooth/jest.config.js         |   6 +
 suite-common/bluetooth/package.json           |   3 +-
 .../bluetooth/src/bluetoothReducer.ts         |   6 +-
 .../bluetooth/src/bluetoothSelectors.ts       |  17 +-
 .../bluetooth/tests/bluetoothReducer.test.ts  | 243 ++++++++++++++++++
 .../tests/bluetoothSelectors.test.ts          |  48 ++++
 suite-common/bluetooth/tsconfig.json          |   2 +-
 yarn.lock                                     |   2 +-
 8 files changed, 315 insertions(+), 12 deletions(-)
 create mode 100644 suite-common/bluetooth/jest.config.js
 create mode 100644 suite-common/bluetooth/tests/bluetoothReducer.test.ts
 create mode 100644 suite-common/bluetooth/tests/bluetoothSelectors.test.ts

diff --git a/suite-common/bluetooth/jest.config.js b/suite-common/bluetooth/jest.config.js
new file mode 100644
index 00000000000..2ef9dc76f5c
--- /dev/null
+++ b/suite-common/bluetooth/jest.config.js
@@ -0,0 +1,6 @@
+const baseConfig = require('../../jest.config.base');
+
+module.exports = {
+    ...baseConfig,
+    roots: ['<rootDir>/src', '<rootDir>/tests', '<rootDir>/../test-utils/__mocks__'],
+};
diff --git a/suite-common/bluetooth/package.json b/suite-common/bluetooth/package.json
index 78accc4a9b8..dbf7271bc6f 100644
--- a/suite-common/bluetooth/package.json
+++ b/suite-common/bluetooth/package.json
@@ -6,12 +6,13 @@
     "sideEffects": false,
     "main": "src/index",
     "scripts": {
+        "test:unit": "yarn g:jest -c ./jest.config.js",
         "depcheck": "yarn g:depcheck",
         "type-check": "yarn g:tsc --build"
     },
     "dependencies": {
         "@reduxjs/toolkit": "1.9.5",
         "@suite-common/redux-utils": "workspace:*",
-        "@suite-common/wallet-core": "workspace:*"
+        "@trezor/connect": "workspace:*"
     }
 }
diff --git a/suite-common/bluetooth/src/bluetoothReducer.ts b/suite-common/bluetooth/src/bluetoothReducer.ts
index 40a53e85b03..def2513ee1e 100644
--- a/suite-common/bluetooth/src/bluetoothReducer.ts
+++ b/suite-common/bluetooth/src/bluetoothReducer.ts
@@ -71,11 +71,13 @@ export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>(
                 bluetoothNearbyDevicesUpdateAction,
                 (state, { payload: { nearbyDevices } }) => {
                     state.nearbyDevices = nearbyDevices
-                        .sort((a, b) => a.lastUpdatedTimestamp - b.lastUpdatedTimestamp)
+                        .sort((a, b) => b.lastUpdatedTimestamp - a.lastUpdatedTimestamp)
                         .map(
                             (device): Draft<BluetoothDeviceState<T>> => ({
                                 device: device as Draft<T>,
-                                status: null,
+                                status:
+                                    state.nearbyDevices.find(it => it.device.id === device.id)
+                                        ?.status ?? null,
                             }),
                         );
                 },
diff --git a/suite-common/bluetooth/src/bluetoothSelectors.ts b/suite-common/bluetooth/src/bluetoothSelectors.ts
index dcd7d07a3e7..96007ed5ea4 100644
--- a/suite-common/bluetooth/src/bluetoothSelectors.ts
+++ b/suite-common/bluetooth/src/bluetoothSelectors.ts
@@ -2,18 +2,19 @@ import { createWeakMapSelector } from '@suite-common/redux-utils';
 
 import { BluetoothDeviceCommon, BluetoothDeviceState, BluetoothState } from './bluetoothReducer';
 
-type State<T extends BluetoothDeviceCommon> = {
+export type WithBluetoothState<T extends BluetoothDeviceCommon> = {
     bluetooth: BluetoothState<T>;
 };
 
-export const selectAdapterStatus = <T extends BluetoothDeviceCommon>(state: State<T>) =>
-    state.bluetooth.adapterStatus;
+export const selectAdapterStatus = <T extends BluetoothDeviceCommon>(
+    state: WithBluetoothState<T>,
+) => state.bluetooth.adapterStatus;
 
-export const selectKnownDevices = <T extends BluetoothDeviceCommon>(state: State<T>) =>
+export const selectKnownDevices = <T extends BluetoothDeviceCommon>(state: WithBluetoothState<T>) =>
     state.bluetooth.knownDevices;
 
 export const prepareSelectAllDevices = <T extends BluetoothDeviceCommon>() =>
-    createWeakMapSelector.withTypes<State<T>>()(
+    createWeakMapSelector.withTypes<WithBluetoothState<T>>()(
         [state => state.bluetooth.nearbyDevices, state => state.bluetooth.knownDevices],
         (nearbyDevices, knownDevices) => {
             const map = new Map<string, BluetoothDeviceState<T>>();
@@ -27,9 +28,11 @@ export const prepareSelectAllDevices = <T extends BluetoothDeviceCommon>() =>
                 }
             });
 
-            return Array.from(map.values());
+            return Array.from(map.values()).sort(
+                (a, b) => b.device.lastUpdatedTimestamp - a.device.lastUpdatedTimestamp,
+            );
         },
     );
 
-export const selectScanStatus = <T extends BluetoothDeviceCommon>(state: State<T>) =>
+export const selectScanStatus = <T extends BluetoothDeviceCommon>(state: WithBluetoothState<T>) =>
     state.bluetooth.scanStatus;
diff --git a/suite-common/bluetooth/tests/bluetoothReducer.test.ts b/suite-common/bluetooth/tests/bluetoothReducer.test.ts
new file mode 100644
index 00000000000..5156db37308
--- /dev/null
+++ b/suite-common/bluetooth/tests/bluetoothReducer.test.ts
@@ -0,0 +1,243 @@
+import { combineReducers } from '@reduxjs/toolkit';
+
+import { TrezorDevice } from '@suite-common/suite-types';
+import { configureMockStore, extraDependenciesMock } from '@suite-common/test-utils';
+import { deviceActions } from '@suite-common/wallet-core';
+import { Device } from '@trezor/connect';
+
+import {
+    BluetoothDeviceState,
+    bluetoothAdapterEventAction,
+    bluetoothConnectDeviceEventAction,
+    bluetoothKnownDevicesUpdateAction,
+    bluetoothNearbyDevicesUpdateAction,
+    bluetoothRemoveKnownDeviceAction,
+    prepareBluetoothReducerCreator,
+} from '../src';
+import { BluetoothDeviceCommon, BluetoothState } from '../src/bluetoothReducer';
+
+const bluetoothReducer =
+    prepareBluetoothReducerCreator<BluetoothDeviceCommon>()(extraDependenciesMock);
+
+const initialState: BluetoothState<BluetoothDeviceCommon> = {
+    adapterStatus: 'unknown',
+    scanStatus: 'idle',
+    nearbyDevices: [] as BluetoothDeviceState<BluetoothDeviceCommon>[],
+    knownDevices: [] as BluetoothDeviceCommon[],
+};
+
+describe('bluetoothReducer', () => {
+    it('sets the bluetooth adapter as enabled/disabled when powered/unpowered', () => {
+        const store = configureMockStore({
+            extra: {},
+            reducer: combineReducers({ bluetooth: bluetoothReducer }),
+            preloadedState: { bluetooth: initialState },
+        });
+
+        expect(store.getState().bluetooth.adapterStatus).toEqual('unknown');
+        store.dispatch(bluetoothAdapterEventAction({ isPowered: true }));
+        expect(store.getState().bluetooth.adapterStatus).toEqual('enabled');
+        store.dispatch(bluetoothAdapterEventAction({ isPowered: false }));
+        expect(store.getState().bluetooth.adapterStatus).toEqual('disabled');
+    });
+
+    it('sorts the devices based on the `lastUpdatedTimestamp` and keeps the status for already existing device', () => {
+        const alreadyExistingNearbyDevice: BluetoothDeviceState<BluetoothDeviceCommon> = {
+            device: {
+                id: 'A',
+                data: [],
+                name: 'Trezor A',
+                lastUpdatedTimestamp: 1,
+            },
+            status: { type: 'pairing' },
+        };
+
+        const nearbyDeviceToBeDropped: BluetoothDeviceState<BluetoothDeviceCommon> = {
+            device: {
+                id: 'B',
+                data: [],
+                name: 'Trezor B',
+                lastUpdatedTimestamp: 2,
+            },
+            status: null,
+        };
+
+        const store = configureMockStore({
+            extra: {},
+            reducer: combineReducers({ bluetooth: bluetoothReducer }),
+            preloadedState: {
+                bluetooth: {
+                    ...initialState,
+                    nearbyDevices: [nearbyDeviceToBeDropped, alreadyExistingNearbyDevice],
+                },
+            },
+        });
+
+        const nearbyDevices: BluetoothDeviceCommon[] = [
+            {
+                id: 'A',
+                data: [],
+                name: 'Trezor A',
+                lastUpdatedTimestamp: 1,
+            },
+            {
+                id: 'C',
+                data: [],
+                name: 'Trezor C',
+                lastUpdatedTimestamp: 3,
+            },
+        ];
+
+        store.dispatch(bluetoothNearbyDevicesUpdateAction({ nearbyDevices }));
+        expect(store.getState().bluetooth.nearbyDevices).toEqual([
+            {
+                device: {
+                    id: 'C',
+                    data: [],
+                    name: 'Trezor C',
+                    lastUpdatedTimestamp: 3,
+                },
+                status: null,
+            },
+            // No `B` device present, it was dropped
+            {
+                device: {
+                    id: 'A',
+                    data: [],
+                    name: 'Trezor A',
+                    lastUpdatedTimestamp: 1,
+                },
+                status: { type: 'pairing' }, // Keeps the pairing status
+            },
+        ]);
+    });
+
+    it('changes the status of the given device during pairing process', () => {
+        const nearbyDevice: BluetoothDeviceState<BluetoothDeviceCommon> = {
+            device: {
+                id: 'A',
+                data: [],
+                name: 'Trezor A',
+                lastUpdatedTimestamp: 1,
+            },
+            status: null,
+        };
+
+        const store = configureMockStore({
+            extra: {},
+            reducer: combineReducers({ bluetooth: bluetoothReducer }),
+            preloadedState: {
+                bluetooth: { ...initialState, nearbyDevices: [nearbyDevice] },
+            },
+        });
+
+        store.dispatch(
+            bluetoothConnectDeviceEventAction({
+                id: 'A',
+                connectionStatus: { type: 'pairing', pin: '12345' },
+            }),
+        );
+        expect(store.getState().bluetooth.nearbyDevices).toEqual([
+            {
+                device: nearbyDevice.device,
+                status: { type: 'pairing', pin: '12345' },
+            },
+        ]);
+    });
+
+    it('updates and removes known devices', () => {
+        const store = configureMockStore({
+            extra: {},
+            reducer: combineReducers({ bluetooth: bluetoothReducer }),
+            preloadedState: { bluetooth: initialState },
+        });
+
+        const knownDeviceToAdd: BluetoothDeviceCommon[] = [
+            {
+                id: 'A',
+                data: [],
+                name: 'Trezor A',
+                lastUpdatedTimestamp: 1,
+            },
+            {
+                id: 'B',
+                data: [],
+                name: 'Trezor B',
+                lastUpdatedTimestamp: 2,
+            },
+        ];
+
+        store.dispatch(bluetoothKnownDevicesUpdateAction({ knownDevices: knownDeviceToAdd }));
+        expect(store.getState().bluetooth.knownDevices).toEqual(knownDeviceToAdd);
+
+        store.dispatch(bluetoothRemoveKnownDeviceAction({ id: 'A' }));
+
+        expect(store.getState().bluetooth.knownDevices).toEqual([
+            {
+                id: 'B',
+                data: [],
+                name: 'Trezor B',
+                lastUpdatedTimestamp: 2,
+            },
+        ]);
+    });
+
+    it('removes device from knownDevices when the device is disconnected by TrezorConnect', () => {
+        const alreadyExistingNearbyDevice: BluetoothDeviceState<BluetoothDeviceCommon> = {
+            device: {
+                id: 'A',
+                data: [],
+                name: 'Trezor A',
+                lastUpdatedTimestamp: 1,
+            },
+            status: { type: 'connected' },
+        };
+
+        const store = configureMockStore({
+            extra: {},
+            reducer: combineReducers({ bluetooth: bluetoothReducer }),
+            preloadedState: {
+                bluetooth: { ...initialState, nearbyDevices: [alreadyExistingNearbyDevice] },
+            },
+        });
+
+        const trezorDevice: Pick<TrezorDevice, 'bluetoothProps'> = {
+            bluetoothProps: { id: 'A' },
+        };
+
+        store.dispatch(deviceActions.deviceDisconnect(trezorDevice as TrezorDevice));
+        expect(store.getState().bluetooth.nearbyDevices).toEqual([]);
+    });
+
+    it('stores a device in `knownDevices` when device is connected by TrezorConnect', () => {
+        const nearbyDevice: BluetoothDeviceState<BluetoothDeviceCommon> = {
+            device: {
+                id: 'A',
+                data: [],
+                name: 'Trezor A',
+                lastUpdatedTimestamp: 1,
+            },
+            status: { type: 'connected' },
+        };
+
+        const store = configureMockStore({
+            extra: {},
+            reducer: combineReducers({ bluetooth: bluetoothReducer }),
+            preloadedState: {
+                bluetooth: { ...initialState, nearbyDevices: [nearbyDevice] },
+            },
+        });
+
+        const trezorDevice: Pick<Device, 'bluetoothProps'> = {
+            bluetoothProps: { id: 'A' },
+        };
+
+        store.dispatch(
+            deviceActions.connectDevice({
+                device: trezorDevice as Device,
+                settings: { defaultWalletLoading: 'passphrase' },
+            }),
+        );
+        expect(store.getState().bluetooth.knownDevices).toEqual([nearbyDevice.device]);
+    });
+});
diff --git a/suite-common/bluetooth/tests/bluetoothSelectors.test.ts b/suite-common/bluetooth/tests/bluetoothSelectors.test.ts
new file mode 100644
index 00000000000..bb685ae5c34
--- /dev/null
+++ b/suite-common/bluetooth/tests/bluetoothSelectors.test.ts
@@ -0,0 +1,48 @@
+import { BluetoothDeviceState, prepareSelectAllDevices } from '../src';
+import { BluetoothDeviceCommon, BluetoothState } from '../src/bluetoothReducer';
+import { WithBluetoothState } from '../src/bluetoothSelectors';
+
+const initialState: BluetoothState<BluetoothDeviceCommon> = {
+    adapterStatus: 'unknown',
+    scanStatus: 'idle',
+    nearbyDevices: [] as BluetoothDeviceState<BluetoothDeviceCommon>[],
+    knownDevices: [] as BluetoothDeviceCommon[],
+};
+
+describe('bluetoothSelectors', () => {
+    it('selects knownDevices and nearbyDevices in one list fot the UI', () => {
+        const selectAllDevices = prepareSelectAllDevices<BluetoothDeviceCommon>();
+
+        const pairingNearbyDeviceA: BluetoothDeviceState<BluetoothDeviceCommon> = {
+            device: {
+                id: 'A',
+                data: [],
+                name: 'Trezor A',
+                lastUpdatedTimestamp: 1,
+            },
+            status: { type: 'pairing' },
+        };
+
+        const knownDeviceB: BluetoothDeviceCommon = {
+            id: 'B',
+            data: [],
+            name: 'Trezor B',
+            lastUpdatedTimestamp: 2,
+        };
+
+        const state: WithBluetoothState<BluetoothDeviceCommon> = {
+            bluetooth: {
+                ...initialState,
+                nearbyDevices: [pairingNearbyDeviceA],
+                knownDevices: [knownDeviceB],
+            },
+        };
+
+        const devices = selectAllDevices(state);
+
+        expect(devices).toEqual([{ device: knownDeviceB, status: null }, pairingNearbyDeviceA]);
+
+        const devicesSecondTime = selectAllDevices(state);
+        expect(devices === devicesSecondTime).toBe(true); // Asserts that `reselect` memoization works
+    });
+});
diff --git a/suite-common/bluetooth/tsconfig.json b/suite-common/bluetooth/tsconfig.json
index 73c744e02f0..67f8eef9919 100644
--- a/suite-common/bluetooth/tsconfig.json
+++ b/suite-common/bluetooth/tsconfig.json
@@ -4,6 +4,6 @@
     "references": [
         { "path": "../redux-utils" },
         { "path": "../suite-types" },
-        { "path": "../wallet-core" }
+        { "path": "../../packages/connect" }
     ]
 }
diff --git a/yarn.lock b/yarn.lock
index fb4d036b0d8..37f0e112dd2 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9610,7 +9610,7 @@ __metadata:
   dependencies:
     "@reduxjs/toolkit": "npm:1.9.5"
     "@suite-common/redux-utils": "workspace:*"
-    "@suite-common/wallet-core": "workspace:*"
+    "@trezor/connect": "workspace:*"
   languageName: unknown
   linkType: soft
 

From 2ebe1bcf260b3b3109d4c65e19abfeaf60290e0b Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Thu, 20 Feb 2025 15:25:12 +0100
Subject: [PATCH 04/12] feat: extract  functionality and add test for it

---
 .../remapKnownDevicesForLinux.test.ts         | 70 +++++++++++++++++++
 .../actions/bluetooth/initBluetoothThunk.ts   | 16 ++---
 .../bluetooth/remapKnownDevicesForLinux.ts    | 27 +++++++
 3 files changed, 101 insertions(+), 12 deletions(-)
 create mode 100644 packages/suite/src/actions/bluetooth/__tests__/remapKnownDevicesForLinux.test.ts
 create mode 100644 packages/suite/src/actions/bluetooth/remapKnownDevicesForLinux.ts

diff --git a/packages/suite/src/actions/bluetooth/__tests__/remapKnownDevicesForLinux.test.ts b/packages/suite/src/actions/bluetooth/__tests__/remapKnownDevicesForLinux.test.ts
new file mode 100644
index 00000000000..18a23db3a45
--- /dev/null
+++ b/packages/suite/src/actions/bluetooth/__tests__/remapKnownDevicesForLinux.test.ts
@@ -0,0 +1,70 @@
+import { BluetoothDevice } from '@trezor/transport-bluetooth';
+
+import { remapKnownDevicesForLinux } from '../remapKnownDevicesForLinux';
+
+const nearbyDeviceA: BluetoothDevice = {
+    id: 'New-Id-A',
+    data: [],
+    name: 'Trezor A',
+    lastUpdatedTimestamp: 1,
+    address: 'Address-Trezor-A-Staying-Same',
+    connected: false,
+    paired: false,
+    rssi: 0,
+};
+
+const nearbyDeviceC: BluetoothDevice = {
+    id: 'C',
+    data: [],
+    name: 'Trezor C',
+    lastUpdatedTimestamp: 1,
+    address: 'Address-Trezor-C',
+    connected: false,
+    paired: false,
+    rssi: 0,
+};
+
+const knownDeviceB: BluetoothDevice = {
+    id: 'B',
+    data: [],
+    name: 'Trezor A',
+    lastUpdatedTimestamp: 1,
+    address: 'Address-Trezor-B',
+    connected: false,
+    paired: false,
+    rssi: 0,
+};
+
+const knownDeviceA: BluetoothDevice = {
+    id: 'Original-Id A',
+    data: [],
+    name: 'Trezor B',
+    lastUpdatedTimestamp: 2,
+    address: 'Address-Trezor-A-Staying-Same',
+    connected: false,
+    paired: false,
+    rssi: 0,
+};
+
+describe(remapKnownDevicesForLinux.name, () => {
+    it('remaps the changed id of the device, while leaving the others intact', () => {
+        const result = remapKnownDevicesForLinux({
+            nearbyDevices: [nearbyDeviceA, nearbyDeviceC],
+            knownDevices: [knownDeviceA, knownDeviceB],
+        });
+
+        expect(result).toEqual([
+            {
+                address: 'Address-Trezor-A-Staying-Same',
+                connected: false,
+                data: [],
+                id: 'New-Id-A',
+                lastUpdatedTimestamp: 2,
+                name: 'Trezor B',
+                paired: false,
+                rssi: 0,
+            },
+            knownDeviceB, // Is kept as it is
+        ]);
+    });
+});
diff --git a/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts b/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts
index 74b242988c5..ca15dbae90e 100644
--- a/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts
+++ b/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts
@@ -10,6 +10,7 @@ import { createThunk } from '@suite-common/redux-utils/';
 import { BluetoothDevice, DeviceConnectionStatus, bluetoothIpc } from '@trezor/transport-bluetooth';
 import { Without } from '@trezor/type-utils';
 
+import { remapKnownDevicesForLinux } from './remapKnownDevicesForLinux';
 import { selectSuiteFlags } from '../../reducers/suite/suiteReducer';
 
 type DeviceConnectionStatusWithOptionalId = Without<DeviceConnectionStatus, 'id'> & {
@@ -35,18 +36,9 @@ export const initBluetoothThunk = createThunk<void, void, void>(
 
             const knownDevices = selectKnownDevices<BluetoothDevice>(getState());
 
-            console.log('nearbyDevices', nearbyDevices);
-
-            // update pairedDevices, id is changed after pairing (linux)
-            const remappedKnownDevices = knownDevices.map(knownDevice => {
-                // find devices with the same address but different id
-                const changed = nearbyDevices.find(
-                    nearbyDevice =>
-                        nearbyDevice.address === knownDevice.address &&
-                        nearbyDevice.id !== knownDevice.id,
-                );
-
-                return changed ? { ...knownDevice, id: changed.id } : knownDevice;
+            const remappedKnownDevices = remapKnownDevicesForLinux({
+                knownDevices,
+                nearbyDevices,
             });
 
             dispatch(bluetoothKnownDevicesUpdateAction({ knownDevices: remappedKnownDevices }));
diff --git a/packages/suite/src/actions/bluetooth/remapKnownDevicesForLinux.ts b/packages/suite/src/actions/bluetooth/remapKnownDevicesForLinux.ts
new file mode 100644
index 00000000000..6ff5b3c91a0
--- /dev/null
+++ b/packages/suite/src/actions/bluetooth/remapKnownDevicesForLinux.ts
@@ -0,0 +1,27 @@
+import { BluetoothDevice } from '@trezor/transport-bluetooth';
+
+type RemapKnownDevicesForLinuxParams = {
+    knownDevices: BluetoothDevice[];
+    nearbyDevices: BluetoothDevice[];
+};
+
+/**
+ * On linux, when bluetooth adapter is turned off/on again, the paired
+ * devices will get different `id`, but `address` will remain the same.
+ *
+ * Therefore, we have to remap the knownDevices to change the `id`.
+ */
+export const remapKnownDevicesForLinux = ({
+    knownDevices,
+    nearbyDevices,
+}: RemapKnownDevicesForLinuxParams): BluetoothDevice[] =>
+    knownDevices.map(knownDevice => {
+        const nearbyDeviceWithSameAddress = nearbyDevices.find(
+            nearbyDevice =>
+                nearbyDevice.address === knownDevice.address && nearbyDevice.id !== knownDevice.id,
+        );
+
+        return nearbyDeviceWithSameAddress
+            ? { ...knownDevice, id: nearbyDeviceWithSameAddress.id }
+            : knownDevice;
+    });

From 6a30f1ff5805850c148192dc271585728f750d1a Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Fri, 21 Feb 2025 13:04:34 +0100
Subject: [PATCH 05/12] fixup! feat: extract  functionality and add test for it

---
 .../bluetooth/tests/bluetoothReducer.test.ts  | 139 ++++++------------
 1 file changed, 42 insertions(+), 97 deletions(-)

diff --git a/suite-common/bluetooth/tests/bluetoothReducer.test.ts b/suite-common/bluetooth/tests/bluetoothReducer.test.ts
index 5156db37308..90fb98cb14a 100644
--- a/suite-common/bluetooth/tests/bluetoothReducer.test.ts
+++ b/suite-common/bluetooth/tests/bluetoothReducer.test.ts
@@ -26,6 +26,36 @@ const initialState: BluetoothState<BluetoothDeviceCommon> = {
     knownDevices: [] as BluetoothDeviceCommon[],
 };
 
+const bluetoothStateDeviceA: BluetoothDeviceState<BluetoothDeviceCommon> = {
+    device: {
+        id: 'A',
+        data: [],
+        name: 'Trezor A',
+        lastUpdatedTimestamp: 1,
+    },
+    status: { type: 'pairing' },
+};
+
+const bluetoothStateDeviceB: BluetoothDeviceState<BluetoothDeviceCommon> = {
+    device: {
+        id: 'B',
+        data: [],
+        name: 'Trezor B',
+        lastUpdatedTimestamp: 2,
+    },
+    status: null,
+};
+
+const bluetoothStateDeviceC: BluetoothDeviceState<BluetoothDeviceCommon> = {
+    device: {
+        id: 'C',
+        data: [],
+        name: 'Trezor C',
+        lastUpdatedTimestamp: 3,
+    },
+    status: null,
+};
+
 describe('bluetoothReducer', () => {
     it('sets the bluetooth adapter as enabled/disabled when powered/unpowered', () => {
         const store = configureMockStore({
@@ -42,92 +72,39 @@ describe('bluetoothReducer', () => {
     });
 
     it('sorts the devices based on the `lastUpdatedTimestamp` and keeps the status for already existing device', () => {
-        const alreadyExistingNearbyDevice: BluetoothDeviceState<BluetoothDeviceCommon> = {
-            device: {
-                id: 'A',
-                data: [],
-                name: 'Trezor A',
-                lastUpdatedTimestamp: 1,
-            },
-            status: { type: 'pairing' },
-        };
-
-        const nearbyDeviceToBeDropped: BluetoothDeviceState<BluetoothDeviceCommon> = {
-            device: {
-                id: 'B',
-                data: [],
-                name: 'Trezor B',
-                lastUpdatedTimestamp: 2,
-            },
-            status: null,
-        };
-
         const store = configureMockStore({
             extra: {},
             reducer: combineReducers({ bluetooth: bluetoothReducer }),
             preloadedState: {
                 bluetooth: {
                     ...initialState,
-                    nearbyDevices: [nearbyDeviceToBeDropped, alreadyExistingNearbyDevice],
+                    nearbyDevices: [bluetoothStateDeviceB, bluetoothStateDeviceA],
                 },
             },
         });
 
         const nearbyDevices: BluetoothDeviceCommon[] = [
-            {
-                id: 'A',
-                data: [],
-                name: 'Trezor A',
-                lastUpdatedTimestamp: 1,
-            },
-            {
-                id: 'C',
-                data: [],
-                name: 'Trezor C',
-                lastUpdatedTimestamp: 3,
-            },
+            bluetoothStateDeviceA.device,
+            bluetoothStateDeviceC.device,
         ];
 
         store.dispatch(bluetoothNearbyDevicesUpdateAction({ nearbyDevices }));
         expect(store.getState().bluetooth.nearbyDevices).toEqual([
-            {
-                device: {
-                    id: 'C',
-                    data: [],
-                    name: 'Trezor C',
-                    lastUpdatedTimestamp: 3,
-                },
-                status: null,
-            },
+            bluetoothStateDeviceC,
             // No `B` device present, it was dropped
             {
-                device: {
-                    id: 'A',
-                    data: [],
-                    name: 'Trezor A',
-                    lastUpdatedTimestamp: 1,
-                },
+                device: bluetoothStateDeviceA.device,
                 status: { type: 'pairing' }, // Keeps the pairing status
             },
         ]);
     });
 
     it('changes the status of the given device during pairing process', () => {
-        const nearbyDevice: BluetoothDeviceState<BluetoothDeviceCommon> = {
-            device: {
-                id: 'A',
-                data: [],
-                name: 'Trezor A',
-                lastUpdatedTimestamp: 1,
-            },
-            status: null,
-        };
-
         const store = configureMockStore({
             extra: {},
             reducer: combineReducers({ bluetooth: bluetoothReducer }),
             preloadedState: {
-                bluetooth: { ...initialState, nearbyDevices: [nearbyDevice] },
+                bluetooth: { ...initialState, nearbyDevices: [bluetoothStateDeviceA] },
             },
         });
 
@@ -139,7 +116,7 @@ describe('bluetoothReducer', () => {
         );
         expect(store.getState().bluetooth.nearbyDevices).toEqual([
             {
-                device: nearbyDevice.device,
+                device: bluetoothStateDeviceA.device,
                 status: { type: 'pairing', pin: '12345' },
             },
         ]);
@@ -153,18 +130,8 @@ describe('bluetoothReducer', () => {
         });
 
         const knownDeviceToAdd: BluetoothDeviceCommon[] = [
-            {
-                id: 'A',
-                data: [],
-                name: 'Trezor A',
-                lastUpdatedTimestamp: 1,
-            },
-            {
-                id: 'B',
-                data: [],
-                name: 'Trezor B',
-                lastUpdatedTimestamp: 2,
-            },
+            bluetoothStateDeviceA.device,
+            bluetoothStateDeviceB.device,
         ];
 
         store.dispatch(bluetoothKnownDevicesUpdateAction({ knownDevices: knownDeviceToAdd }));
@@ -172,32 +139,15 @@ describe('bluetoothReducer', () => {
 
         store.dispatch(bluetoothRemoveKnownDeviceAction({ id: 'A' }));
 
-        expect(store.getState().bluetooth.knownDevices).toEqual([
-            {
-                id: 'B',
-                data: [],
-                name: 'Trezor B',
-                lastUpdatedTimestamp: 2,
-            },
-        ]);
+        expect(store.getState().bluetooth.knownDevices).toEqual([bluetoothStateDeviceB.device]);
     });
 
     it('removes device from knownDevices when the device is disconnected by TrezorConnect', () => {
-        const alreadyExistingNearbyDevice: BluetoothDeviceState<BluetoothDeviceCommon> = {
-            device: {
-                id: 'A',
-                data: [],
-                name: 'Trezor A',
-                lastUpdatedTimestamp: 1,
-            },
-            status: { type: 'connected' },
-        };
-
         const store = configureMockStore({
             extra: {},
             reducer: combineReducers({ bluetooth: bluetoothReducer }),
             preloadedState: {
-                bluetooth: { ...initialState, nearbyDevices: [alreadyExistingNearbyDevice] },
+                bluetooth: { ...initialState, nearbyDevices: [bluetoothStateDeviceA] },
             },
         });
 
@@ -211,12 +161,7 @@ describe('bluetoothReducer', () => {
 
     it('stores a device in `knownDevices` when device is connected by TrezorConnect', () => {
         const nearbyDevice: BluetoothDeviceState<BluetoothDeviceCommon> = {
-            device: {
-                id: 'A',
-                data: [],
-                name: 'Trezor A',
-                lastUpdatedTimestamp: 1,
-            },
+            device: bluetoothStateDeviceA.device,
             status: { type: 'connected' },
         };
 

From 20fcc715922b30b9b128e5c153fdee558c97dbc0 Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Fri, 21 Feb 2025 13:05:04 +0100
Subject: [PATCH 06/12] fixup! feat: move reducers into seperate common
 package, create shared state for mobile

---
 suite-common/bluetooth/src/bluetoothReducer.ts | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/suite-common/bluetooth/src/bluetoothReducer.ts b/suite-common/bluetooth/src/bluetoothReducer.ts
index def2513ee1e..bb72d4e6da3 100644
--- a/suite-common/bluetooth/src/bluetoothReducer.ts
+++ b/suite-common/bluetooth/src/bluetoothReducer.ts
@@ -35,21 +35,21 @@ export type BluetoothDeviceCommon = {
 
 export type DeviceBluetoothStatusType = DeviceBluetoothStatus['type'];
 
+export type BluetoothDeviceState<T extends BluetoothDeviceCommon> = {
+    device: T;
+    status: DeviceBluetoothStatus | null;
+};
+
 export type BluetoothState<T extends BluetoothDeviceCommon> = {
     adapterStatus: 'unknown' | 'enabled' | 'disabled';
     scanStatus: BluetoothScanStatus;
-    nearbyDevices: Array<{ device: T; status: DeviceBluetoothStatus | null }>;
+    nearbyDevices: BluetoothDeviceState<T>[];
 
     // This will be persisted, those are devices we believed that are paired
     // (because we already successfully paired them in the Suite) in the Operating System
     knownDevices: T[];
 };
 
-export type BluetoothDeviceState<T extends BluetoothDeviceCommon> = {
-    device: T;
-    status: DeviceBluetoothStatus | null;
-};
-
 export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>() => {
     const initialState: BluetoothState<T> = {
         adapterStatus: 'unknown',

From 1d22b88882b3e493a535f620bcf7eb02d69dcbef Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Fri, 21 Feb 2025 13:07:04 +0100
Subject: [PATCH 07/12] fixup! feat: extract  functionality and add test for it

---
 suite-common/bluetooth/tests/bluetoothReducer.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/suite-common/bluetooth/tests/bluetoothReducer.test.ts b/suite-common/bluetooth/tests/bluetoothReducer.test.ts
index 90fb98cb14a..aa9804eacc7 100644
--- a/suite-common/bluetooth/tests/bluetoothReducer.test.ts
+++ b/suite-common/bluetooth/tests/bluetoothReducer.test.ts
@@ -142,7 +142,7 @@ describe('bluetoothReducer', () => {
         expect(store.getState().bluetooth.knownDevices).toEqual([bluetoothStateDeviceB.device]);
     });
 
-    it('removes device from knownDevices when the device is disconnected by TrezorConnect', () => {
+    it('removes device from nearbyDevices when the device is disconnected by TrezorConnect', () => {
         const store = configureMockStore({
             extra: {},
             reducer: combineReducers({ bluetooth: bluetoothReducer }),

From eb34bdba41922e2b1389f66e435a85696ddb7c1e Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Fri, 21 Feb 2025 13:42:29 +0100
Subject: [PATCH 08/12] fixup! feat: implement suite-common bluetooth code into
 Suite

---
 .../views/settings/SettingsDevice/BluetoothEraseBonds.tsx | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx b/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx
index 469dae32936..18d31aed008 100644
--- a/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx
+++ b/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx
@@ -13,7 +13,7 @@ export const BluetoothEraseBonds = () => {
 
     const [inProgress, setInProgress] = useState(false);
 
-    const onCheckFirmwareAuthenticity = async () => {
+    const onEraseClick = async () => {
         setInProgress(true);
         // TODO: missing button request in FW
         const result = await TrezorConnect.eraseBonds({ device });
@@ -33,11 +33,7 @@ export const BluetoothEraseBonds = () => {
                 description="Forget pairing credentials. Trezor will no longer be paired with this computer (require bluetooth module restart? or device disconnect? forget your device in system UI?)"
             />
             <ActionColumn>
-                <Button
-                    onClick={onCheckFirmwareAuthenticity}
-                    isLoading={inProgress}
-                    isDisabled={inProgress}
-                >
+                <Button onClick={onEraseClick} isLoading={inProgress} isDisabled={inProgress}>
                     Erase
                 </Button>
             </ActionColumn>

From c9d03f1c53bd912f59473ec39ffee6b69c044802 Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Fri, 21 Feb 2025 13:47:30 +0100
Subject: [PATCH 09/12] fixup! feat: move reducers into seperate common
 package, create shared state for mobile

---
 suite-common/bluetooth/src/bluetoothSelectors.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/suite-common/bluetooth/src/bluetoothSelectors.ts b/suite-common/bluetooth/src/bluetoothSelectors.ts
index 96007ed5ea4..8e952616ec8 100644
--- a/suite-common/bluetooth/src/bluetoothSelectors.ts
+++ b/suite-common/bluetooth/src/bluetoothSelectors.ts
@@ -13,6 +13,14 @@ export const selectAdapterStatus = <T extends BluetoothDeviceCommon>(
 export const selectKnownDevices = <T extends BluetoothDeviceCommon>(state: WithBluetoothState<T>) =>
     state.bluetooth.knownDevices;
 
+/**
+ * We need to have generic `createWeakMapSelector.withTypes` so we need to wrap it into Higher Order Function,
+ * but we need to make sure it is called only **once** to not break the memoization. So it is named
+ * `prepareSelectAllDevices` and shall be called **outside** of the component to create a selector with
+ * concrete type:
+ *
+ * For example: `const selectAllDevices = prepareSelectAllDevices<ConcreteBluetoothDevice>();`
+ */
 export const prepareSelectAllDevices = <T extends BluetoothDeviceCommon>() =>
     createWeakMapSelector.withTypes<WithBluetoothState<T>>()(
         [state => state.bluetooth.nearbyDevices, state => state.bluetooth.knownDevices],

From 9dcc1e1826b25145cd16dff528b5fe8070021979 Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Fri, 21 Feb 2025 15:48:27 +0100
Subject: [PATCH 10/12] fixup! feat: move reducers into seperate common
 package, create shared state for mobile

---
 .../bluetooth/src/bluetoothActions.ts         | 26 ++++++++---------
 .../bluetooth/src/bluetoothReducer.ts         | 28 ++++++++-----------
 suite-common/bluetooth/src/index.ts           | 11 +-------
 .../bluetooth/tests/bluetoothReducer.test.ts  | 24 ++++++----------
 4 files changed, 35 insertions(+), 54 deletions(-)

diff --git a/suite-common/bluetooth/src/bluetoothActions.ts b/suite-common/bluetooth/src/bluetoothActions.ts
index d7593fa3465..bf43e7a7ec2 100644
--- a/suite-common/bluetooth/src/bluetoothActions.ts
+++ b/suite-common/bluetooth/src/bluetoothActions.ts
@@ -8,7 +8,7 @@ import {
 
 export const BLUETOOTH_PREFIX = '@suite/bluetooth';
 
-export const bluetoothAdapterEventAction = createAction(
+const adapterEventAction = createAction(
     `${BLUETOOTH_PREFIX}/adapter-event`,
     ({ isPowered }: { isPowered: boolean }) => ({ payload: { isPowered } }),
 );
@@ -17,7 +17,7 @@ type BluetoothNearbyDevicesUpdateActionPayload = {
     nearbyDevices: BluetoothDeviceCommon[];
 };
 
-export const bluetoothNearbyDevicesUpdateAction = createAction(
+const nearbyDevicesUpdateAction = createAction(
     `${BLUETOOTH_PREFIX}/nearby-devices-update`,
     ({ nearbyDevices }: BluetoothNearbyDevicesUpdateActionPayload) => ({
         payload: { nearbyDevices },
@@ -28,37 +28,37 @@ type BluetoothKnownDevicesUpdateActionPayload = {
     knownDevices: BluetoothDeviceCommon[];
 };
 
-export const bluetoothKnownDevicesUpdateAction = createAction(
+const knownDevicesUpdateAction = createAction(
     `${BLUETOOTH_PREFIX}/known-devices-update`,
     ({ knownDevices }: BluetoothKnownDevicesUpdateActionPayload) => ({
         payload: { knownDevices },
     }),
 );
 
-export const bluetoothRemoveKnownDeviceAction = createAction(
+const removeKnownDeviceAction = createAction(
     `${BLUETOOTH_PREFIX}/remove-known-device`,
     ({ id }: { id: string }) => ({
         payload: { id },
     }),
 );
 
-export const bluetoothConnectDeviceEventAction = createAction(
+const connectDeviceEventAction = createAction(
     `${BLUETOOTH_PREFIX}/connect-device-event`,
     ({ connectionStatus, id }: { id: string; connectionStatus: DeviceBluetoothStatus }) => ({
         payload: { id, connectionStatus },
     }),
 );
 
-export const bluetoothScanStatusAction = createAction(
+const scanStatusAction = createAction(
     `${BLUETOOTH_PREFIX}/scan-status`,
     ({ status }: { status: BluetoothScanStatus }) => ({ payload: { status } }),
 );
 
-export const allBluetoothActions = {
-    bluetoothAdapterEventAction,
-    bluetoothNearbyDevicesUpdateAction,
-    bluetoothConnectDeviceEventAction,
-    bluetoothScanStatusAction,
-    bluetoothKnownDevicesUpdateAction,
-    bluetoothRemoveKnownDeviceAction,
+export const bluetoothActions = {
+    adapterEventAction,
+    nearbyDevicesUpdateAction,
+    connectDeviceEventAction,
+    scanStatusAction,
+    knownDevicesUpdateAction,
+    removeKnownDeviceAction,
 };
diff --git a/suite-common/bluetooth/src/bluetoothReducer.ts b/suite-common/bluetooth/src/bluetoothReducer.ts
index bb72d4e6da3..b092ad39093 100644
--- a/suite-common/bluetooth/src/bluetoothReducer.ts
+++ b/suite-common/bluetooth/src/bluetoothReducer.ts
@@ -3,14 +3,7 @@ import { AnyAction, Draft } from '@reduxjs/toolkit';
 import { createReducerWithExtraDeps } from '@suite-common/redux-utils';
 import { deviceActions } from '@suite-common/wallet-core';
 
-import {
-    bluetoothAdapterEventAction,
-    bluetoothConnectDeviceEventAction,
-    bluetoothKnownDevicesUpdateAction,
-    bluetoothNearbyDevicesUpdateAction,
-    bluetoothRemoveKnownDeviceAction,
-    bluetoothScanStatusAction,
-} from './bluetoothActions';
+import { bluetoothActions } from './bluetoothActions';
 
 export type BluetoothScanStatus = 'idle' | 'running' | 'error';
 
@@ -60,7 +53,7 @@ export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>(
 
     return createReducerWithExtraDeps<BluetoothState<T>>(initialState, (builder, extra) =>
         builder
-            .addCase(bluetoothAdapterEventAction, (state, { payload: { isPowered } }) => {
+            .addCase(bluetoothActions.adapterEventAction, (state, { payload: { isPowered } }) => {
                 state.adapterStatus = isPowered ? 'enabled' : 'disabled';
                 if (!isPowered) {
                     state.nearbyDevices = [];
@@ -68,7 +61,7 @@ export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>(
                 }
             })
             .addCase(
-                bluetoothNearbyDevicesUpdateAction,
+                bluetoothActions.nearbyDevicesUpdateAction,
                 (state, { payload: { nearbyDevices } }) => {
                     state.nearbyDevices = nearbyDevices
                         .sort((a, b) => b.lastUpdatedTimestamp - a.lastUpdatedTimestamp)
@@ -83,7 +76,7 @@ export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>(
                 },
             )
             .addCase(
-                bluetoothConnectDeviceEventAction,
+                bluetoothActions.connectDeviceEventAction,
                 (state, { payload: { id, connectionStatus } }) => {
                     const device = state.nearbyDevices.find(it => it.device.id === id);
 
@@ -92,15 +85,18 @@ export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>(
                     }
                 },
             )
-            .addCase(bluetoothKnownDevicesUpdateAction, (state, { payload: { knownDevices } }) => {
-                state.knownDevices = knownDevices as Draft<T>[];
-            })
-            .addCase(bluetoothRemoveKnownDeviceAction, (state, { payload: { id } }) => {
+            .addCase(
+                bluetoothActions.knownDevicesUpdateAction,
+                (state, { payload: { knownDevices } }) => {
+                    state.knownDevices = knownDevices as Draft<T>[];
+                },
+            )
+            .addCase(bluetoothActions.removeKnownDeviceAction, (state, { payload: { id } }) => {
                 state.knownDevices = state.knownDevices.filter(
                     knownDevice => knownDevice.id !== id,
                 );
             })
-            .addCase(bluetoothScanStatusAction, (state, { payload: { status } }) => {
+            .addCase(bluetoothActions.scanStatusAction, (state, { payload: { status } }) => {
                 state.scanStatus = status;
             })
             .addCase(deviceActions.deviceDisconnect, (state, { payload: { bluetoothProps } }) => {
diff --git a/suite-common/bluetooth/src/index.ts b/suite-common/bluetooth/src/index.ts
index dfb4615599e..7fe15e21c01 100644
--- a/suite-common/bluetooth/src/index.ts
+++ b/suite-common/bluetooth/src/index.ts
@@ -1,13 +1,4 @@
-export {
-    bluetoothAdapterEventAction,
-    BLUETOOTH_PREFIX,
-    allBluetoothActions,
-    bluetoothConnectDeviceEventAction,
-    bluetoothNearbyDevicesUpdateAction,
-    bluetoothKnownDevicesUpdateAction,
-    bluetoothRemoveKnownDeviceAction,
-    bluetoothScanStatusAction,
-} from './bluetoothActions';
+export { BLUETOOTH_PREFIX, bluetoothActions } from './bluetoothActions';
 
 export { prepareBluetoothReducerCreator } from './bluetoothReducer';
 export type {
diff --git a/suite-common/bluetooth/tests/bluetoothReducer.test.ts b/suite-common/bluetooth/tests/bluetoothReducer.test.ts
index aa9804eacc7..b6a0af53c30 100644
--- a/suite-common/bluetooth/tests/bluetoothReducer.test.ts
+++ b/suite-common/bluetooth/tests/bluetoothReducer.test.ts
@@ -5,15 +5,7 @@ import { configureMockStore, extraDependenciesMock } from '@suite-common/test-ut
 import { deviceActions } from '@suite-common/wallet-core';
 import { Device } from '@trezor/connect';
 
-import {
-    BluetoothDeviceState,
-    bluetoothAdapterEventAction,
-    bluetoothConnectDeviceEventAction,
-    bluetoothKnownDevicesUpdateAction,
-    bluetoothNearbyDevicesUpdateAction,
-    bluetoothRemoveKnownDeviceAction,
-    prepareBluetoothReducerCreator,
-} from '../src';
+import { BluetoothDeviceState, bluetoothActions, prepareBluetoothReducerCreator } from '../src';
 import { BluetoothDeviceCommon, BluetoothState } from '../src/bluetoothReducer';
 
 const bluetoothReducer =
@@ -65,9 +57,9 @@ describe('bluetoothReducer', () => {
         });
 
         expect(store.getState().bluetooth.adapterStatus).toEqual('unknown');
-        store.dispatch(bluetoothAdapterEventAction({ isPowered: true }));
+        store.dispatch(bluetoothActions.adapterEventAction({ isPowered: true }));
         expect(store.getState().bluetooth.adapterStatus).toEqual('enabled');
-        store.dispatch(bluetoothAdapterEventAction({ isPowered: false }));
+        store.dispatch(bluetoothActions.adapterEventAction({ isPowered: false }));
         expect(store.getState().bluetooth.adapterStatus).toEqual('disabled');
     });
 
@@ -88,7 +80,7 @@ describe('bluetoothReducer', () => {
             bluetoothStateDeviceC.device,
         ];
 
-        store.dispatch(bluetoothNearbyDevicesUpdateAction({ nearbyDevices }));
+        store.dispatch(bluetoothActions.nearbyDevicesUpdateAction({ nearbyDevices }));
         expect(store.getState().bluetooth.nearbyDevices).toEqual([
             bluetoothStateDeviceC,
             // No `B` device present, it was dropped
@@ -109,7 +101,7 @@ describe('bluetoothReducer', () => {
         });
 
         store.dispatch(
-            bluetoothConnectDeviceEventAction({
+            bluetoothActions.connectDeviceEventAction({
                 id: 'A',
                 connectionStatus: { type: 'pairing', pin: '12345' },
             }),
@@ -134,10 +126,12 @@ describe('bluetoothReducer', () => {
             bluetoothStateDeviceB.device,
         ];
 
-        store.dispatch(bluetoothKnownDevicesUpdateAction({ knownDevices: knownDeviceToAdd }));
+        store.dispatch(
+            bluetoothActions.knownDevicesUpdateAction({ knownDevices: knownDeviceToAdd }),
+        );
         expect(store.getState().bluetooth.knownDevices).toEqual(knownDeviceToAdd);
 
-        store.dispatch(bluetoothRemoveKnownDeviceAction({ id: 'A' }));
+        store.dispatch(bluetoothActions.removeKnownDeviceAction({ id: 'A' }));
 
         expect(store.getState().bluetooth.knownDevices).toEqual([bluetoothStateDeviceB.device]);
     });

From e0b0c76ef47ddad87b5f13e9f62346e7e209f026 Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Fri, 21 Feb 2025 15:49:20 +0100
Subject: [PATCH 11/12] fixup! feat: implement suite-common bluetooth code into
 Suite

---
 .../bluetooth/bluetoothStartScanningThunk.ts  |  4 ++--
 .../bluetooth/bluetoothStopScanningThunk.ts   |  4 ++--
 .../actions/bluetooth/initBluetoothThunk.ts   | 19 +++++++------------
 .../suite/bluetooth/BluetoothConnect.tsx      | 13 ++++++-------
 .../middlewares/wallet/storageMiddleware.ts   |  4 ++--
 packages/suite/src/types/suite/index.ts       |  4 ++--
 .../SettingsDevice/BluetoothEraseBonds.tsx    |  4 ++--
 7 files changed, 23 insertions(+), 29 deletions(-)

diff --git a/packages/suite/src/actions/bluetooth/bluetoothStartScanningThunk.ts b/packages/suite/src/actions/bluetooth/bluetoothStartScanningThunk.ts
index 90af08320ea..62d222f9562 100644
--- a/packages/suite/src/actions/bluetooth/bluetoothStartScanningThunk.ts
+++ b/packages/suite/src/actions/bluetooth/bluetoothStartScanningThunk.ts
@@ -1,11 +1,11 @@
-import { BLUETOOTH_PREFIX, bluetoothScanStatusAction } from '@suite-common/bluetooth';
+import { BLUETOOTH_PREFIX, bluetoothActions } from '@suite-common/bluetooth';
 import { createThunk } from '@suite-common/redux-utils';
 import { bluetoothIpc } from '@trezor/transport-bluetooth';
 
 export const bluetoothStartScanningThunk = createThunk<void, void, void>(
     `${BLUETOOTH_PREFIX}/bluetoothStartScanningThunk`,
     (_, { dispatch }) => {
-        dispatch(bluetoothScanStatusAction({ status: 'running' }));
+        dispatch(bluetoothActions.scanStatusAction({ status: 'running' }));
         // This can fail, but if there is an error we already got it from `adapter-event`
         // and user is informed about it (bluetooth turned-off, ...)
         bluetoothIpc.startScan();
diff --git a/packages/suite/src/actions/bluetooth/bluetoothStopScanningThunk.ts b/packages/suite/src/actions/bluetooth/bluetoothStopScanningThunk.ts
index 445c92db5e9..9599c1d0a2c 100644
--- a/packages/suite/src/actions/bluetooth/bluetoothStopScanningThunk.ts
+++ b/packages/suite/src/actions/bluetooth/bluetoothStopScanningThunk.ts
@@ -1,11 +1,11 @@
-import { BLUETOOTH_PREFIX, bluetoothScanStatusAction } from '@suite-common/bluetooth';
+import { BLUETOOTH_PREFIX, bluetoothActions } from '@suite-common/bluetooth';
 import { createThunk } from '@suite-common/redux-utils';
 import { bluetoothIpc } from '@trezor/transport-bluetooth';
 
 export const bluetoothStopScanningThunk = createThunk<void, void, void>(
     `${BLUETOOTH_PREFIX}/bluetoothStopScanningThunk`,
     (_, { dispatch }) => {
-        dispatch(bluetoothScanStatusAction({ status: 'idle' }));
+        dispatch(bluetoothActions.scanStatusAction({ status: 'idle' }));
         // This can fail, but there is nothing we can do about it
         bluetoothIpc.stopScan();
     },
diff --git a/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts b/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts
index ca15dbae90e..f9e16b2bed3 100644
--- a/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts
+++ b/packages/suite/src/actions/bluetooth/initBluetoothThunk.ts
@@ -1,11 +1,4 @@
-import {
-    BLUETOOTH_PREFIX,
-    bluetoothAdapterEventAction,
-    bluetoothConnectDeviceEventAction,
-    bluetoothKnownDevicesUpdateAction,
-    bluetoothNearbyDevicesUpdateAction,
-    selectKnownDevices,
-} from '@suite-common/bluetooth';
+import { BLUETOOTH_PREFIX, bluetoothActions, selectKnownDevices } from '@suite-common/bluetooth';
 import { createThunk } from '@suite-common/redux-utils/';
 import { BluetoothDevice, DeviceConnectionStatus, bluetoothIpc } from '@trezor/transport-bluetooth';
 import { Without } from '@trezor/type-utils';
@@ -28,7 +21,7 @@ export const initBluetoothThunk = createThunk<void, void, void>(
 
         bluetoothIpc.on('adapter-event', isPowered => {
             console.warn('adapter-event', isPowered);
-            dispatch(bluetoothAdapterEventAction({ isPowered }));
+            dispatch(bluetoothActions.adapterEventAction({ isPowered }));
         });
 
         bluetoothIpc.on('device-list-update', nearbyDevices => {
@@ -41,8 +34,10 @@ export const initBluetoothThunk = createThunk<void, void, void>(
                 nearbyDevices,
             });
 
-            dispatch(bluetoothKnownDevicesUpdateAction({ knownDevices: remappedKnownDevices }));
-            dispatch(bluetoothNearbyDevicesUpdateAction({ nearbyDevices }));
+            dispatch(
+                bluetoothActions.knownDevicesUpdateAction({ knownDevices: remappedKnownDevices }),
+            );
+            dispatch(bluetoothActions.nearbyDevicesUpdateAction({ nearbyDevices }));
         });
 
         bluetoothIpc.on('device-connection-status', connectionStatus => {
@@ -53,7 +48,7 @@ export const initBluetoothThunk = createThunk<void, void, void>(
             delete copyConnectionStatus.id; // So we dont pollute redux store
 
             dispatch(
-                bluetoothConnectDeviceEventAction({
+                bluetoothActions.connectDeviceEventAction({
                     id: connectionStatus.id,
                     connectionStatus: copyConnectionStatus,
                 }),
diff --git a/packages/suite/src/components/suite/bluetooth/BluetoothConnect.tsx b/packages/suite/src/components/suite/bluetooth/BluetoothConnect.tsx
index 85d567312e8..7b35d598df8 100644
--- a/packages/suite/src/components/suite/bluetooth/BluetoothConnect.tsx
+++ b/packages/suite/src/components/suite/bluetooth/BluetoothConnect.tsx
@@ -1,8 +1,7 @@
 import { useCallback, useEffect, useState } from 'react';
 
 import {
-    bluetoothConnectDeviceEventAction,
-    bluetoothScanStatusAction,
+    bluetoothActions,
     prepareSelectAllDevices,
     selectAdapterStatus,
     selectScanStatus,
@@ -66,7 +65,7 @@ export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) =>
     useEffect(() => {
         // Intentionally no `clearScamTimer`, this is first run and if we use this we would create infinite re-render
         const timerId = setTimeout(() => {
-            dispatch(bluetoothScanStatusAction({ status: 'idle' }));
+            dispatch(bluetoothActions.scanStatusAction({ status: 'idle' }));
         }, SCAN_TIMEOUT);
 
         setScannerTimerId(timerId);
@@ -74,11 +73,11 @@ export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) =>
 
     const onReScanClick = () => {
         setSelectedDeviceId(null);
-        dispatch(bluetoothScanStatusAction({ status: 'running' }));
+        dispatch(bluetoothActions.scanStatusAction({ status: 'running' }));
 
         clearScamTimer();
         const timerId = setTimeout(() => {
-            dispatch(bluetoothScanStatusAction({ status: 'idle' }));
+            dispatch(bluetoothActions.scanStatusAction({ status: 'idle' }));
         }, SCAN_TIMEOUT);
         setScannerTimerId(timerId);
     };
@@ -89,7 +88,7 @@ export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) =>
 
         if (!result.success) {
             dispatch(
-                bluetoothConnectDeviceEventAction({
+                bluetoothActions.connectDeviceEventAction({
                     id,
                     connectionStatus: { type: 'error', error: result.error },
                 }),
@@ -102,7 +101,7 @@ export const BluetoothConnect = ({ onClose, uiMode }: BluetoothConnectProps) =>
             );
         } else {
             dispatch(
-                bluetoothConnectDeviceEventAction({
+                bluetoothActions.connectDeviceEventAction({
                     id,
                     connectionStatus: { type: 'connected' },
                 }),
diff --git a/packages/suite/src/middlewares/wallet/storageMiddleware.ts b/packages/suite/src/middlewares/wallet/storageMiddleware.ts
index e554d79f1ad..0c076712804 100644
--- a/packages/suite/src/middlewares/wallet/storageMiddleware.ts
+++ b/packages/suite/src/middlewares/wallet/storageMiddleware.ts
@@ -2,7 +2,7 @@ import { isAnyOf } from '@reduxjs/toolkit';
 import { MiddlewareAPI } from 'redux';
 
 import { analyticsActions } from '@suite-common/analytics';
-import { bluetoothKnownDevicesUpdateAction } from '@suite-common/bluetooth';
+import { bluetoothActions } from '@suite-common/bluetooth';
 import { messageSystemActions } from '@suite-common/message-system';
 import { isDeviceRemembered } from '@suite-common/suite-utils';
 import { TokenManagementAction } from '@suite-common/token-definitions';
@@ -205,7 +205,7 @@ const storageMiddleware = (api: MiddlewareAPI<Dispatch, AppState>) => {
 
             if (
                 deviceActions.connectDevice.match(action) ||
-                bluetoothKnownDevicesUpdateAction.match(action)
+                bluetoothActions.knownDevicesUpdateAction.match(action)
             ) {
                 api.dispatch(storageActions.saveKnownDevices());
             }
diff --git a/packages/suite/src/types/suite/index.ts b/packages/suite/src/types/suite/index.ts
index b63d2dc67e5..e50629c434f 100644
--- a/packages/suite/src/types/suite/index.ts
+++ b/packages/suite/src/types/suite/index.ts
@@ -2,7 +2,7 @@ import type { Store as ReduxStore } from 'redux';
 import type { ThunkAction as TAction, ThunkDispatch } from 'redux-thunk';
 
 import { analyticsActions } from '@suite-common/analytics';
-import { allBluetoothActions } from '@suite-common/bluetooth';
+import { bluetoothActions } from '@suite-common/bluetooth';
 import { deviceAuthenticityActions } from '@suite-common/device-authenticity';
 import { firmwareActions } from '@suite-common/firmware';
 import { messageSystemActions } from '@suite-common/message-system';
@@ -58,7 +58,7 @@ type DiscoveryAction = ReturnType<(typeof discoveryActions)[keyof typeof discove
 type DeviceAuthenticityAction = ReturnType<
     (typeof deviceAuthenticityActions)[keyof typeof deviceAuthenticityActions]
 >;
-type BluetoothAction = ReturnType<(typeof allBluetoothActions)[keyof typeof allBluetoothActions]>;
+type BluetoothAction = ReturnType<(typeof bluetoothActions)[keyof typeof bluetoothActions]>;
 
 // all actions from all apps used to properly type Dispatch.
 export type Action =
diff --git a/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx b/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx
index 18d31aed008..53b59729a13 100644
--- a/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx
+++ b/packages/suite/src/views/settings/SettingsDevice/BluetoothEraseBonds.tsx
@@ -1,6 +1,6 @@
 import { useState } from 'react';
 
-import { bluetoothRemoveKnownDeviceAction } from '@suite-common/bluetooth';
+import { bluetoothActions } from '@suite-common/bluetooth';
 import { Button } from '@trezor/components';
 import TrezorConnect from '@trezor/connect';
 
@@ -19,7 +19,7 @@ export const BluetoothEraseBonds = () => {
         const result = await TrezorConnect.eraseBonds({ device });
 
         if (device?.bluetoothProps?.id !== undefined) {
-            dispatch(bluetoothRemoveKnownDeviceAction({ id: device.bluetoothProps.id }));
+            dispatch(bluetoothActions.removeKnownDeviceAction({ id: device.bluetoothProps.id }));
         }
 
         console.warn('Erase bonds!', result);

From fe0378a017be8c0e0c1e4b46c34b98c554d9f0cb Mon Sep 17 00:00:00 2001
From: Peter Sanderson <dierk.deidel@protonmail.com>
Date: Fri, 21 Feb 2025 16:16:04 +0100
Subject: [PATCH 12/12] fixup! feat: move reducers into seperate common
 package, create shared state for mobile

---
 .../bluetooth/src/bluetoothSelectors.ts       | 11 ++---
 .../tests/bluetoothSelectors.test.ts          | 40 +++++++++----------
 2 files changed, 26 insertions(+), 25 deletions(-)

diff --git a/suite-common/bluetooth/src/bluetoothSelectors.ts b/suite-common/bluetooth/src/bluetoothSelectors.ts
index 8e952616ec8..64cd49cad38 100644
--- a/suite-common/bluetooth/src/bluetoothSelectors.ts
+++ b/suite-common/bluetooth/src/bluetoothSelectors.ts
@@ -26,13 +26,14 @@ export const prepareSelectAllDevices = <T extends BluetoothDeviceCommon>() =>
         [state => state.bluetooth.nearbyDevices, state => state.bluetooth.knownDevices],
         (nearbyDevices, knownDevices) => {
             const map = new Map<string, BluetoothDeviceState<T>>();
-            knownDevices.forEach(knownDevice => {
-                map.set(knownDevice.id, { device: knownDevice, status: null });
-            });
 
             nearbyDevices.forEach(nearbyDevice => {
-                if (!map.has(nearbyDevice.device.id)) {
-                    map.set(nearbyDevice.device.id, nearbyDevice);
+                map.set(nearbyDevice.device.id, nearbyDevice);
+            });
+
+            knownDevices.forEach(knownDevice => {
+                if (!map.has(knownDevice.id)) {
+                    map.set(knownDevice.id, { device: knownDevice, status: null });
                 }
             });
 
diff --git a/suite-common/bluetooth/tests/bluetoothSelectors.test.ts b/suite-common/bluetooth/tests/bluetoothSelectors.test.ts
index bb685ae5c34..375dddd75c4 100644
--- a/suite-common/bluetooth/tests/bluetoothSelectors.test.ts
+++ b/suite-common/bluetooth/tests/bluetoothSelectors.test.ts
@@ -9,38 +9,38 @@ const initialState: BluetoothState<BluetoothDeviceCommon> = {
     knownDevices: [] as BluetoothDeviceCommon[],
 };
 
+const pairingDeviceStateA: BluetoothDeviceState<BluetoothDeviceCommon> = {
+    device: {
+        id: 'A',
+        data: [],
+        name: 'Trezor A',
+        lastUpdatedTimestamp: 1,
+    },
+    status: { type: 'pairing' },
+};
+
+const deviceB: BluetoothDeviceCommon = {
+    id: 'B',
+    data: [],
+    name: 'Trezor B',
+    lastUpdatedTimestamp: 2,
+};
+
 describe('bluetoothSelectors', () => {
     it('selects knownDevices and nearbyDevices in one list fot the UI', () => {
         const selectAllDevices = prepareSelectAllDevices<BluetoothDeviceCommon>();
 
-        const pairingNearbyDeviceA: BluetoothDeviceState<BluetoothDeviceCommon> = {
-            device: {
-                id: 'A',
-                data: [],
-                name: 'Trezor A',
-                lastUpdatedTimestamp: 1,
-            },
-            status: { type: 'pairing' },
-        };
-
-        const knownDeviceB: BluetoothDeviceCommon = {
-            id: 'B',
-            data: [],
-            name: 'Trezor B',
-            lastUpdatedTimestamp: 2,
-        };
-
         const state: WithBluetoothState<BluetoothDeviceCommon> = {
             bluetooth: {
                 ...initialState,
-                nearbyDevices: [pairingNearbyDeviceA],
-                knownDevices: [knownDeviceB],
+                nearbyDevices: [pairingDeviceStateA],
+                knownDevices: [pairingDeviceStateA.device, deviceB],
             },
         };
 
         const devices = selectAllDevices(state);
 
-        expect(devices).toEqual([{ device: knownDeviceB, status: null }, pairingNearbyDeviceA]);
+        expect(devices).toEqual([{ device: deviceB, status: null }, pairingDeviceStateA]);
 
         const devicesSecondTime = selectAllDevices(state);
         expect(devices === devicesSecondTime).toBe(true); // Asserts that `reselect` memoization works