Extract reducers to common package

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
+        ]);
+    });
+});

packages/suite/src/actions/bluetooth/bluetoothConnectDeviceThunk.ts

@@ -1,15 +1,43 @@
+import { BLUETOOTH_PREFIX, bluetoothActions } from '@suite-common/bluetooth';
 import { createThunk } from '@suite-common/redux-utils';
+import { notificationsActions } from '@suite-common/toast-notifications';
 import { bluetoothIpc } from '@trezor/transport-bluetooth';
 
-import { BLUETOOTH_PREFIX } from './bluetoothActions';
+type BluetoothConnectDeviceThunkResult = {
+    success: boolean;
+};
 
-type ThunkResponse = ReturnType<typeof bluetoothIpc.connectDevice>;
-
-export const bluetoothConnectDeviceThunk = createThunk<ThunkResponse, { id: string }, void>(
+export const bluetoothConnectDeviceThunk = createThunk<
+    BluetoothConnectDeviceThunkResult,
+    { id: string },
+    void
+>(
     `${BLUETOOTH_PREFIX}/bluetoothConnectDeviceThunk`,
-    async ({ id }, { fulfillWithValue }) => {
+    async ({ id }, { fulfillWithValue, dispatch }) => {
         const result = await bluetoothIpc.connectDevice(id);
 
-        return fulfillWithValue(result);
+        if (!result.success) {
+            dispatch(
+                bluetoothActions.connectDeviceEventAction({
+                    id,
+                    connectionStatus: { type: 'error', error: result.error },
+                }),
+            );
+            dispatch(
+                notificationsActions.addToast({
+                    type: 'error',
+                    error: result.error,
+                }),
+            );
+        } else {
+            dispatch(
+                bluetoothActions.connectDeviceEventAction({
+                    id,
+                    connectionStatus: { type: 'connected' },
+                }),
+            );
+        }
+
+        return fulfillWithValue({ success: result.success });
     },
 );

packages/suite/src/actions/bluetooth/bluetoothStartScanningThunk.ts

@@ -1,11 +1,11 @@
+import { BLUETOOTH_PREFIX, bluetoothActions } 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(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();

packages/suite/src/actions/bluetooth/bluetoothStopScanningThunk.ts

@@ -1,11 +1,11 @@
+import { BLUETOOTH_PREFIX, bluetoothActions } 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(bluetoothActions.scanStatusAction({ status: 'idle' }));
         // This can fail, but there is nothing we can do about it
         bluetoothIpc.stopScan();
     },

packages/suite/src/actions/bluetooth/initBluetoothThunk.ts

@@ -1,13 +1,9 @@
+import { BLUETOOTH_PREFIX, bluetoothActions, selectKnownDevices } from '@suite-common/bluetooth';
 import { createThunk } from '@suite-common/redux-utils/';
-import { DeviceConnectionStatus, bluetoothIpc } from '@trezor/transport-bluetooth';
+import { BluetoothDevice, DeviceConnectionStatus, bluetoothIpc } from '@trezor/transport-bluetooth';
 import { Without } from '@trezor/type-utils';
 
-import {
-    BLUETOOTH_PREFIX,
-    bluetoothAdapterEventAction,
-    bluetoothConnectDeviceEventAction,
-    bluetoothDeviceListUpdate,
-} from './bluetoothActions';
+import { remapKnownDevicesForLinux } from './remapKnownDevicesForLinux';
 import { selectSuiteFlags } from '../../reducers/suite/suiteReducer';
 
 type DeviceConnectionStatusWithOptionalId = Without<DeviceConnectionStatus, 'id'> & {
@@ -25,12 +21,23 @@ 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', 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());
+
+            const remappedKnownDevices = remapKnownDevicesForLinux({
+                knownDevices,
+                nearbyDevices,
+            });
+
+            dispatch(
+                bluetoothActions.knownDevicesUpdateAction({ knownDevices: remappedKnownDevices }),
+            );
+            dispatch(bluetoothActions.nearbyDevicesUpdateAction({ nearbyDevices }));
         });
 
         bluetoothIpc.on('device-connection-status', connectionStatus => {
@@ -41,15 +48,15 @@ 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,
                 }),
             );
         });
 
         // TODO: this should be called after trezor/connect init?
-        const knownDevices = getState().bluetooth.pairedDevices;
+        const knownDevices = selectKnownDevices<BluetoothDevice>(getState());
         await bluetoothIpc.init({ knownDevices });
     },
 );

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;
+    });

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) => {

packages/suite/src/actions/wallet/addWalletThunk.ts

@@ -44,7 +44,13 @@ export const addWalletThunk = createThunk<
     const discovery = selectDiscoveryByDeviceState(getState(), device?.state);
     const discoveryStatus = getDiscoveryStatus({ device, discovery });
 
-    if (discoveryStatus !== undefined && discoveryStatus.status === 'loading') {
+    if (
+        discoveryStatus !== undefined &&
+        discoveryStatus.status === 'loading' &&
+        // There are situations where we are in the "state" of discovery, but we want to allow for adding a wallet.
+        // See: https://github.com/trezor/trezor-suite/issues/17114 for example
+        discoveryStatus.type === 'discovery'
+    ) {
         return;
     }