feat: update shared state fro bluetooth to accomodate changes in the ipc

peter-sanderson · peter-sanderson · commit 74955999f8b9 · 2025-03-12T11:37:01.000+01:00
diff --git a/suite-common/bluetooth/src/bluetoothActions.ts b/suite-common/bluetooth/src/bluetoothActions.ts
@@ -1,10 +1,6 @@
 import { createAction } from '@reduxjs/toolkit';
 
-import {
-    BluetoothDeviceCommon,
-    BluetoothScanStatus,
-    DeviceBluetoothStatus,
-} from './bluetoothReducer';
+import { BluetoothDeviceCommon, BluetoothScanStatus } from './bluetoothReducer';
 
 export const BLUETOOTH_PREFIX = '@suite/bluetooth';
 
@@ -44,8 +40,8 @@ const removeKnownDeviceAction = createAction(
 
 const connectDeviceEventAction = createAction(
     `${BLUETOOTH_PREFIX}/connect-device-event`,
-    ({ connectionStatus, id }: { id: string; connectionStatus: DeviceBluetoothStatus }) => ({
-        payload: { id, connectionStatus },
+    ({ device }: { device: BluetoothDeviceCommon }) => ({
+        payload: { device },
     }),
 );
 
diff --git a/suite-common/bluetooth/src/bluetoothReducer.ts b/suite-common/bluetooth/src/bluetoothReducer.ts
@@ -7,14 +7,19 @@ import { bluetoothActions } from './bluetoothActions';
 
 export type BluetoothScanStatus = 'idle' | 'running' | 'error';
 
-export type DeviceBluetoothStatus =
+export type DeviceBluetoothConnectionStatus =
+    | { type: 'disconnected' }
     | { type: 'pairing'; pin?: string }
     | { type: 'paired' }
     | { type: 'connecting' }
     | { type: 'connected' }
     | {
-          type: 'error';
+          type: 'pairing-error'; // This device cannot be paired ever again (new macAddress, new device)
           error: string;
+      }
+    | {
+          type: 'connection-error'; // Out-of-range, offline, in the faraday cage, ...
+          error: string; // Timeout, connection aborted, ...
       };
 
 // Do not export this outside of this suite-common package, Suite uses ist own type
@@ -24,19 +29,15 @@ export type BluetoothDeviceCommon = {
     name: string;
     data: number[]; // Todo: consider typed data-structure for this
     lastUpdatedTimestamp: number;
+    connectionStatus: DeviceBluetoothConnectionStatus;
 };
 
-export type DeviceBluetoothStatusType = DeviceBluetoothStatus['type'];
-
-export type BluetoothDeviceState<T extends BluetoothDeviceCommon> = {
-    device: T;
-    status: DeviceBluetoothStatus | null;
-};
+export type DeviceBluetoothConnectionStatusType = DeviceBluetoothConnectionStatus['type'];
 
 export type BluetoothState<T extends BluetoothDeviceCommon> = {
     adapterStatus: 'unknown' | 'enabled' | 'disabled';
     scanStatus: BluetoothScanStatus;
-    nearbyDevices: BluetoothDeviceState<T>[];
+    nearbyDevices: T[]; // Must be sorted, newest last
 
     // 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
@@ -47,7 +48,7 @@ export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>(
     const initialState: BluetoothState<T> = {
         adapterStatus: 'unknown',
         scanStatus: 'idle',
-        nearbyDevices: [] as BluetoothDeviceState<T>[],
+        nearbyDevices: [] as T[],
         knownDevices: [] as T[],
     };
 
@@ -64,25 +65,27 @@ export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>(
                 bluetoothActions.nearbyDevicesUpdateAction,
                 (state, { payload: { nearbyDevices } }) => {
                     state.nearbyDevices = nearbyDevices
-                        .sort((a, b) => b.lastUpdatedTimestamp - a.lastUpdatedTimestamp)
-                        .map(
-                            (device): Draft<BluetoothDeviceState<T>> => ({
-                                device: device as Draft<T>,
-                                status:
-                                    state.nearbyDevices.find(it => it.device.id === device.id)
-                                        ?.status ?? null,
-                            }),
-                        );
+                        // Devices with 'pairing-error' status should NOT be displayed in the list, as it
+                        // won't be possible to connect to them ever again. User has to start pairing again,
+                        // which would produce a device with new id.
+                        .filter(
+                            nearbyDevice => nearbyDevice.connectionStatus?.type !== 'pairing-error',
+                        )
+                        .sort(
+                            (a, b) => b.lastUpdatedTimestamp - a.lastUpdatedTimestamp,
+                        ) as Draft<T>[];
                 },
             )
             .addCase(
                 bluetoothActions.connectDeviceEventAction,
-                (state, { payload: { id, connectionStatus } }) => {
-                    const device = state.nearbyDevices.find(it => it.device.id === id);
+                (state, { payload: { device } }) => {
+                    state.nearbyDevices = state.nearbyDevices.map(it =>
+                        it.id === device.id ? device : it,
+                    ) as Draft<T>[];
 
-                    if (device !== undefined) {
-                        device.status = connectionStatus;
-                    }
+                    state.knownDevices = state.knownDevices.map(it =>
+                        it.id === device.id ? device : it,
+                    ) as Draft<T>[];
                 },
             )
             .addCase(
@@ -102,7 +105,7 @@ export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>(
             .addCase(deviceActions.deviceDisconnect, (state, { payload: { bluetoothProps } }) => {
                 if (bluetoothProps !== undefined) {
                     state.nearbyDevices = state.nearbyDevices.filter(
-                        it => it.device.id !== bluetoothProps.id,
+                        it => it.id !== bluetoothProps.id,
                     );
                 }
             })
@@ -120,26 +123,32 @@ export const prepareBluetoothReducerCreator = <T extends BluetoothDeviceCommon>(
                         return;
                     }
 
-                    const deviceState = state.nearbyDevices.find(
-                        it => it.device.id === bluetoothProps.id,
-                    );
+                    const device = state.nearbyDevices.find(it => it.id === bluetoothProps.id);
 
-                    if (deviceState !== undefined) {
+                    if (device !== 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);
+                            state.knownDevices.push(device);
                         }
                     }
                 },
             )
             .addMatcher(
                 action => action.type === extra.actionTypes.storageLoad,
                 (state, action: AnyAction) => {
-                    state.knownDevices = action.payload.knownDevices?.bluetooth ?? [];
+                    const loadedKnownDevices = (action.payload.knownDevices?.bluetooth ??
+                        []) as T[];
+
+                    state.knownDevices = loadedKnownDevices.map(
+                        (it): T => ({
+                            ...it,
+                            connectionStatus: { type: 'disconnected' },
+                        }),
+                    ) as Draft<T>[];
                 },
             ),
     );
diff --git a/suite-common/bluetooth/src/bluetoothSelectors.ts b/suite-common/bluetooth/src/bluetoothSelectors.ts
@@ -1,6 +1,6 @@
 import { createWeakMapSelector } from '@suite-common/redux-utils';
 
-import { BluetoothDeviceCommon, BluetoothDeviceState, BluetoothState } from './bluetoothReducer';
+import { BluetoothDeviceCommon, BluetoothState } from './bluetoothReducer';
 
 export type WithBluetoothState<T extends BluetoothDeviceCommon> = {
     bluetooth: BluetoothState<T>;
@@ -25,21 +25,19 @@ export const prepareSelectAllDevices = <T extends BluetoothDeviceCommon>() =>
     createWeakMapSelector.withTypes<WithBluetoothState<T>>()(
         [state => state.bluetooth.nearbyDevices, state => state.bluetooth.knownDevices],
         (nearbyDevices, knownDevices) => {
-            const map = new Map<string, BluetoothDeviceState<T>>();
+            const map = new Map<string, T>();
 
-            nearbyDevices.forEach(nearbyDevice => {
-                map.set(nearbyDevice.device.id, nearbyDevice);
-            });
+            knownDevices.forEach(knownDevice => map.set(knownDevice.id, knownDevice));
+
+            const nearbyDevicesCopy = [...nearbyDevices];
+            nearbyDevicesCopy.reverse(); // We want to have the newest devices first in the UI
 
-            knownDevices.forEach(knownDevice => {
-                if (!map.has(knownDevice.id)) {
-                    map.set(knownDevice.id, { device: knownDevice, status: null });
-                }
+            nearbyDevicesCopy.forEach(nearbyDevice => {
+                map.delete(nearbyDevice.id); // Delete and re-add to change the order, replace would keep original order
+                map.set(nearbyDevice.id, nearbyDevice);
             });
 
-            return Array.from(map.values()).sort(
-                (a, b) => b.device.lastUpdatedTimestamp - a.device.lastUpdatedTimestamp,
-            );
+            return Array.from(map.values());
         },
     );
 
diff --git a/suite-common/bluetooth/src/index.ts b/suite-common/bluetooth/src/index.ts
@@ -1,11 +1,7 @@
 export { BLUETOOTH_PREFIX, bluetoothActions } from './bluetoothActions';
 
 export { prepareBluetoothReducerCreator } from './bluetoothReducer';
-export type {
-    BluetoothDeviceState,
-    BluetoothScanStatus,
-    DeviceBluetoothStatusType,
-} from './bluetoothReducer';
+export type { BluetoothScanStatus, DeviceBluetoothConnectionStatusType } from './bluetoothReducer';
 
 export {
     prepareSelectAllDevices,
diff --git a/suite-common/bluetooth/tests/bluetoothReducer.test.ts b/suite-common/bluetooth/tests/bluetoothReducer.test.ts
@@ -5,7 +5,7 @@ import { configureMockStore, extraDependenciesMock } from '@suite-common/test-ut
 import { deviceActions } from '@suite-common/wallet-core';
 import { Device } from '@trezor/connect';
 
-import { BluetoothDeviceState, bluetoothActions, prepareBluetoothReducerCreator } from '../src';
+import { bluetoothActions, prepareBluetoothReducerCreator } from '../src';
 import { BluetoothDeviceCommon, BluetoothState } from '../src/bluetoothReducer';
 
 const bluetoothReducer =
@@ -14,38 +14,24 @@ const bluetoothReducer =
 const initialState: BluetoothState<BluetoothDeviceCommon> = {
     adapterStatus: 'unknown',
     scanStatus: 'idle',
-    nearbyDevices: [] as BluetoothDeviceState<BluetoothDeviceCommon>[],
+    nearbyDevices: [] as BluetoothDeviceCommon[],
     knownDevices: [] as BluetoothDeviceCommon[],
 };
 
-const bluetoothStateDeviceA: BluetoothDeviceState<BluetoothDeviceCommon> = {
-    device: {
-        id: 'A',
-        data: [],
-        name: 'Trezor A',
-        lastUpdatedTimestamp: 1,
-    },
-    status: { type: 'pairing' },
+const pairingDeviceA: BluetoothDeviceCommon = {
+    id: 'A',
+    data: [],
+    name: 'Trezor A',
+    lastUpdatedTimestamp: 1,
+    connectionStatus: { 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,
+const disconnectedDeviceB: BluetoothDeviceCommon = {
+    id: 'B',
+    data: [],
+    name: 'Trezor B',
+    lastUpdatedTimestamp: 2,
+    connectionStatus: { type: 'disconnected' },
 };
 
 describe('bluetoothReducer', () => {
@@ -63,53 +49,27 @@ describe('bluetoothReducer', () => {
         expect(store.getState().bluetooth.adapterStatus).toEqual('disabled');
     });
 
-    it('sorts the devices based on the `lastUpdatedTimestamp` and keeps the status for already existing device', () => {
-        const store = configureMockStore({
-            extra: {},
-            reducer: combineReducers({ bluetooth: bluetoothReducer }),
-            preloadedState: {
-                bluetooth: {
-                    ...initialState,
-                    nearbyDevices: [bluetoothStateDeviceB, bluetoothStateDeviceA],
-                },
-            },
-        });
-
-        const nearbyDevices: BluetoothDeviceCommon[] = [
-            bluetoothStateDeviceA.device,
-            bluetoothStateDeviceC.device,
-        ];
-
-        store.dispatch(bluetoothActions.nearbyDevicesUpdateAction({ nearbyDevices }));
-        expect(store.getState().bluetooth.nearbyDevices).toEqual([
-            bluetoothStateDeviceC,
-            // No `B` device present, it was dropped
-            {
-                device: bluetoothStateDeviceA.device,
-                status: { type: 'pairing' }, // Keeps the pairing status
-            },
-        ]);
-    });
-
     it('changes the status of the given device during pairing process', () => {
         const store = configureMockStore({
             extra: {},
             reducer: combineReducers({ bluetooth: bluetoothReducer }),
             preloadedState: {
-                bluetooth: { ...initialState, nearbyDevices: [bluetoothStateDeviceA] },
+                bluetooth: { ...initialState, nearbyDevices: [pairingDeviceA] },
             },
         });
 
         store.dispatch(
             bluetoothActions.connectDeviceEventAction({
-                id: 'A',
-                connectionStatus: { type: 'pairing', pin: '12345' },
+                device: {
+                    ...pairingDeviceA,
+                    connectionStatus: { type: 'pairing', pin: '12345' },
+                },
             }),
         );
         expect(store.getState().bluetooth.nearbyDevices).toEqual([
             {
-                device: bluetoothStateDeviceA.device,
-                status: { type: 'pairing', pin: '12345' },
+                ...pairingDeviceA,
+                connectionStatus: { type: 'pairing', pin: '12345' },
             },
         ]);
     });
@@ -121,10 +81,7 @@ describe('bluetoothReducer', () => {
             preloadedState: { bluetooth: initialState },
         });
 
-        const knownDeviceToAdd: BluetoothDeviceCommon[] = [
-            bluetoothStateDeviceA.device,
-            bluetoothStateDeviceB.device,
-        ];
+        const knownDeviceToAdd: BluetoothDeviceCommon[] = [pairingDeviceA, disconnectedDeviceB];
 
         store.dispatch(
             bluetoothActions.knownDevicesUpdateAction({ knownDevices: knownDeviceToAdd }),
@@ -133,15 +90,15 @@ describe('bluetoothReducer', () => {
 
         store.dispatch(bluetoothActions.removeKnownDeviceAction({ id: 'A' }));
 
-        expect(store.getState().bluetooth.knownDevices).toEqual([bluetoothStateDeviceB.device]);
+        expect(store.getState().bluetooth.knownDevices).toEqual([disconnectedDeviceB]);
     });
 
     it('removes device from nearbyDevices when the device is disconnected by TrezorConnect', () => {
         const store = configureMockStore({
             extra: {},
             reducer: combineReducers({ bluetooth: bluetoothReducer }),
             preloadedState: {
-                bluetooth: { ...initialState, nearbyDevices: [bluetoothStateDeviceA] },
+                bluetooth: { ...initialState, nearbyDevices: [pairingDeviceA] },
             },
         });
 
@@ -154,9 +111,9 @@ describe('bluetoothReducer', () => {
     });
 
     it('stores a device in `knownDevices` when device is connected by TrezorConnect', () => {
-        const nearbyDevice: BluetoothDeviceState<BluetoothDeviceCommon> = {
-            device: bluetoothStateDeviceA.device,
-            status: { type: 'connected' },
+        const nearbyDevice: BluetoothDeviceCommon = {
+            ...pairingDeviceA,
+            connectionStatus: { type: 'connected' },
         };
 
         const store = configureMockStore({
@@ -177,6 +134,6 @@ describe('bluetoothReducer', () => {
                 settings: { defaultWalletLoading: 'passphrase' },
             }),
         );
-        expect(store.getState().bluetooth.knownDevices).toEqual([nearbyDevice.device]);
+        expect(store.getState().bluetooth.knownDevices).toEqual([nearbyDevice]);
     });
 });
diff --git a/suite-common/bluetooth/tests/bluetoothSelectors.test.ts b/suite-common/bluetooth/tests/bluetoothSelectors.test.ts
