@ledgerhq/live-common 34.52.0 → 34.52.1

package/src/deviceSDK/hooks/useUpdateFirmware.ts

@@ -10,6 +10,7 @@ const STATE_UPDATE_THROTTLE = 500;
 
 export type UseUpdateFirmwareArgs = {
   deviceId: string;
+  deviceName: string | null;
   updateFirmwareAction?: typeof defaultUpdateFirmwareAction;
 };
 
@@ -22,6 +23,7 @@ export type UseUpdateFirmwareArgs = {
  */
 export function useUpdateFirmware({
   deviceId,
+  deviceName,
   updateFirmwareAction = defaultUpdateFirmwareAction,
 }: UseUpdateFirmwareArgs): {
   updateState: UpdateFirmwareActionState;
@@ -34,6 +36,7 @@ export function useUpdateFirmware({
     if (nonce > 0) {
       const sub = updateFirmwareAction({
         deviceId,
+        deviceName,
       })
         .pipe(
           // in order to correctly throttle the events without losing any important events
@@ -52,7 +55,7 @@ export function useUpdateFirmware({
         sub.unsubscribe();
       };
     }
-  }, [deviceId, updateFirmwareAction, nonce]);
+  }, [deviceId, updateFirmwareAction, nonce, deviceName]);
 
   const triggerUpdate = useCallback(() => {
     setUpdateState(initialState);

package/src/deviceSDK/tasks/getBatteryStatuses.ts

@@ -12,6 +12,7 @@ import getBatteryStatus from "../commands/getBatteryStatus";
 
 export type GetBatteryStatusesTaskArgs = {
   deviceId: DeviceId;
+  deviceName: string | null;
   statuses: BatteryStatusTypes[];
 };
 
@@ -30,10 +31,14 @@ export type GetBatteryStatusesTaskEvent =
 
 function internalGetBatteryStatusesTask({
   deviceId,
+  deviceName,
   statuses,
 }: GetBatteryStatusesTaskArgs): Observable<GetBatteryStatusesTaskEvent> {
   return new Observable(subscriber => {
-    return withTransport(deviceId)(({ transportRef }) =>
+    return withTransport(
+      deviceId,
+      deviceName ? { matchDeviceByName: deviceName } : undefined,
+    )(({ transportRef }) =>
       quitApp(transportRef.current).pipe(
         switchMap(() => {
           const statusesObservable = statuses.map(statusType =>

package/src/deviceSDK/tasks/getDeviceInfo.ts

@@ -15,7 +15,7 @@ import { withTransport } from "../transports/core";
 const ManagerAllowedFlag = 0x08;
 const PinValidatedFlag = 0x80;
 
-export type GetDeviceInfoTaskArgs = { deviceId: DeviceId };
+export type GetDeviceInfoTaskArgs = { deviceId: DeviceId; deviceName: string | null };
 
 // No taskError for getDeviceInfoTask. Kept for consistency with other tasks.
 export type GetDeviceInfoTaskError = "None";
@@ -33,10 +33,14 @@ export type GetDeviceInfoTaskEvent =
 // Exported for tests
 export function internalGetDeviceInfoTask({
   deviceId,
+  deviceName,
 }: GetDeviceInfoTaskArgs): Observable<GetDeviceInfoTaskEvent> {
   return new Observable(subscriber => {
     return (
-      withTransport(deviceId)(({ transportRef }) =>
+      withTransport(
+        deviceId,
+        deviceName ? { matchDeviceByName: deviceName } : undefined,
+      )(({ transportRef }) =>
         quitApp(transportRef.current).pipe(
           switchMap(() => {
             return retryOnErrorsCommandWrapper({

package/src/deviceSDK/tasks/getLatestFirmware.ts

@@ -10,6 +10,7 @@ import { getLatestFirmwareForDeviceUseCase } from "../../device/use-cases/getLat
 
 export type GetLatestFirmwareTaskArgs = {
   deviceId: DeviceId;
+  deviceName: string | null;
   deviceInfo: DeviceInfo;
 };
 
@@ -27,10 +28,14 @@ export type GetLatestFirmwareTaskEvent =
 
 function internalGetLatestFirmwareTask({
   deviceId,
+  deviceName,
   deviceInfo,
 }: GetLatestFirmwareTaskArgs): Observable<GetLatestFirmwareTaskEvent> {
   return new Observable(subscriber => {
-    return withDevice(deviceId)(transport =>
+    return withDevice(
+      deviceId,
+      deviceName ? { matchDeviceByName: deviceName } : undefined,
+    )(transport =>
       quitApp(transport).pipe(
         switchMap(() => {
           return from(getLatestFirmwareForDeviceUseCase(deviceInfo));

package/src/deviceSDK/tasks/toggleOnboardingEarlyCheck.test.ts

@@ -26,6 +26,7 @@ describe("@deviceSDK/tasks/toggleOnboardingEarlyCheckTask", () => {
       // `enter` and `exit` have the same behavior
       toggleOnboardingEarlyCheckTask({
         deviceId: "",
+        deviceName: null,
         toggleType: "exit",
       }).subscribe({
         next: event => {
@@ -47,6 +48,7 @@ describe("@deviceSDK/tasks/toggleOnboardingEarlyCheckTask", () => {
 
       toggleOnboardingEarlyCheckTask({
         deviceId: "",
+        deviceName: null,
         toggleType: "enter",
       }).subscribe({
         next: event => {
@@ -78,6 +80,7 @@ describe("@deviceSDK/tasks/toggleOnboardingEarlyCheckTask", () => {
 
       toggleOnboardingEarlyCheckTask({
         deviceId: "",
+        deviceName: null,
         toggleType: "enter",
       }).subscribe({
         next: event => {

package/src/deviceSDK/tasks/toggleOnboardingEarlyCheck.ts

@@ -26,11 +26,13 @@ export type ToggleOnboardingEarlyCheckTaskEvent =
 
 export type ToggleOnboardingEarlyCheckTaskArgs = {
   deviceId: DeviceId;
+  deviceName: string | null;
   toggleType: "enter" | "exit";
 };
 
 function internalToggleOnboardingEarlyCheckTask({
   deviceId,
+  deviceName,
   toggleType,
 }: ToggleOnboardingEarlyCheckTaskArgs): Observable<ToggleOnboardingEarlyCheckTaskEvent> {
   const tracer = new LocalTracer(LOG_TYPE, {
@@ -42,7 +44,10 @@ function internalToggleOnboardingEarlyCheckTask({
   const p2 = toggleType === "enter" ? ToggleTypeP2.EnterChecking : ToggleTypeP2.ExitChecking;
 
   return new Observable(subscriber => {
-    withTransport(deviceId)(({ transportRef }) =>
+    withTransport(
+      deviceId,
+      deviceName ? { matchDeviceByName: deviceName } : undefined,
+    )(({ transportRef }) =>
       toggleOnboardingEarlyCheckCmd({
         transport: transportRef.current,
         p2,

package/src/deviceSDK/tasks/updateFirmware.ts

@@ -40,6 +40,7 @@ import {
 
 export type UpdateFirmwareTaskArgs = {
   deviceId: DeviceId;
+  deviceName: string | null;
   updateContext: FirmwareUpdateContext;
 };
 
@@ -83,6 +84,7 @@ const waitForGetVersion = retryOnErrorsCommandWrapper({
 
 function internalUpdateFirmwareTask({
   deviceId,
+  deviceName,
   updateContext,
 }: UpdateFirmwareTaskArgs): Observable<UpdateFirmwareTaskEvent> {
   const tracer = new LocalTracer(LOG_TYPE, {
@@ -90,7 +92,10 @@ function internalUpdateFirmwareTask({
   });
 
   return new Observable(subscriber => {
-    const sub = withTransport(deviceId)(({ transportRef }) =>
+    const sub = withTransport(
+      deviceId,
+      deviceName ? { matchDeviceByName: deviceName } : undefined,
+    )(({ transportRef }) =>
       concat(
         quitApp(transportRef.current).pipe(
           switchMap(() => {

package/src/deviceSDK/transports/core.ts

@@ -63,7 +63,10 @@ export type JobArgs = {
  *  job: the job to execute with the transport. It takes:
  *   - transportRef: a reference to the transport that can be updated by calling a transportRef.refreshTransport()
  */
-export const withTransport = (deviceId: string, options?: { openTimeoutMs?: number }) => {
+export const withTransport = (
+  deviceId: string,
+  options?: { openTimeoutMs?: number; matchDeviceByName?: string },
+) => {
   return <T>(job: ({ transportRef }: JobArgs) => Observable<T>): Observable<T> =>
     new Observable(subscriber => {
       const queuedJobManager = DeviceQueuedJobsManager.getInstance();
@@ -149,7 +152,7 @@ export const withTransport = (deviceId: string, options?: { openTimeoutMs?: numb
             close(transportRef.current, deviceId)
               // Silently ignore errors on transport close
               .catch(() => {})
-              .then(async () => open(deviceId, options?.openTimeoutMs, tracer.getContext()))
+              .then(async () => open(deviceId, options, tracer.getContext()))
               .then(async newTransport => {
                 await setupTransport(transportRef.current);
 
@@ -176,7 +179,7 @@ export const withTransport = (deviceId: string, options?: { openTimeoutMs?: numb
             currentJobId: jobId,
           });
 
-          return open(deviceId, options?.openTimeoutMs, tracer.getContext());
+          return open(deviceId, options, tracer.getContext());
         })
         .then(transport => {
           return buildRefreshableTransport(transport);

package/src/hw/actions/app.ts

@@ -468,12 +468,13 @@ export const createAction = (
     );
 
     const task: (arg0: ConnectAppInput) => Observable<ConnectAppEvent> = useCallback(
-      ({ deviceId, request }: ConnectAppInput) => {
+      ({ deviceId, deviceName, request }: ConnectAppInput) => {
         //To avoid redundant checks, we remove passed checks from the request.
         const { dependencies, requireLatestFirmware } = request;
 
         return connectAppExec({
           deviceId,
+          deviceName,
           request: {
             ...request,
             dependencies: dependenciesResolvedRef.current ? undefined : dependencies,

package/src/hw/actions/customLockScreenLoad.ts

@@ -37,7 +37,7 @@ type ActionState = State & {
   onRetry: () => void;
 };
 
-type LoadImageAction = Action<LoadImageRequest, ActionState, LoadimageResult>;
+type LoadImageAction = Action<LoadImageRequest | undefined, ActionState, LoadimageResult>;
 
 const mapResult = ({ imageHash, imageSize }: State) => ({
   imageHash,
@@ -131,12 +131,16 @@ export const reducer = (state: State, e: Event): State => {
 export const createAction = (
   task: (arg0: LoadImageInput) => Observable<LoadImageEvent>,
 ): LoadImageAction => {
-  const useHook = (device: Device | null | undefined, request: LoadImageRequest): ActionState => {
+  const useHook = (
+    device: Device | null | undefined,
+    request: LoadImageRequest | undefined,
+  ): ActionState => {
     const [state, setState] = useState(() => getInitialState(device));
     const [resetIndex, setResetIndex] = useState(0);
     const deviceSubject = useReplaySubject(device);
 
     useEffect(() => {
+      if (!request) return;
       if (state.imageLoaded) return;
 
       const impl = getImplementation(currentMode)<LoadImageEvent, LoadImageRequest>({

package/src/hw/actions/implementations.ts

@@ -46,7 +46,11 @@ type PollingImplementationConfig = {
 
 type PollingImplementationParams<Request, EmittedEvents> = {
   deviceSubject: ReplaySubject<Device | null | undefined>;
-  task: (params: { deviceId: string; request: Request }) => Observable<EmittedEvents>;
+  task: (params: {
+    deviceId: string;
+    deviceName: string | null;
+    request: Request;
+  }) => Observable<EmittedEvents>;
   request: Request;
   config?: PollingImplementationConfig;
   // retryableWithDelayDisconnectedErrors has default value of [DisconnectedDevice, DisconnectedDeviceDuringOperation]
@@ -120,7 +124,11 @@ const pollingImplementation: Implementation = <SpecificType, GenericRequestType>
             device: currentDevice,
             replaceable: !firstRound,
           }),
-          task({ deviceId: currentDevice.deviceId, request }),
+          task({
+            deviceId: currentDevice.deviceId,
+            deviceName: currentDevice.deviceName ?? null,
+            request,
+          }),
         )
           .pipe(
             // Any event should clear the initialTimeout.
@@ -230,7 +238,13 @@ const eventImplementation: Implementation = <SpecificType, GenericRequestType>(
 
             return concat(
               initialEvent,
-              !device ? EMPTY : task({ deviceId: device.deviceId, request }),
+              device
+                ? task({
+                    deviceId: device.deviceId,
+                    deviceName: device.deviceName ?? null,
+                    request,
+                  })
+                : EMPTY,
             );
           }),
           catchError((error: Error) =>

package/src/hw/connectApp.ts

@@ -48,6 +48,7 @@ export type RequiresDerivation = {
 };
 export type Input = {
   deviceId: string;
+  deviceName: string | null;
   request: ConnectAppRequest;
 };
 export type ConnectAppRequest = {
@@ -524,10 +525,13 @@ export default function connectAppFactory(
   } = { isLdmkConnectAppEnabled: false },
 ) {
   if (!isLdmkConnectAppEnabled) {
-    return ({ deviceId, request }: Input): Observable<ConnectAppEvent> =>
-      withDevice(deviceId)(transport => cmd(transport, { deviceId, request }));
+    return ({ deviceId, deviceName, request }: Input): Observable<ConnectAppEvent> =>
+      withDevice(
+        deviceId,
+        deviceName ? { matchDeviceByName: deviceName } : undefined,
+      )(transport => cmd(transport, { deviceId, deviceName, request }));
   }
-  return ({ deviceId, request }: Input): Observable<ConnectAppEvent> => {
+  return ({ deviceId, deviceName, request }: Input): Observable<ConnectAppEvent> => {
     const {
       appName,
       requiresDerivation,
@@ -535,9 +539,12 @@ export default function connectAppFactory(
       requireLatestFirmware,
       allowPartialDependencies = false,
     } = request;
-    return withDevice(deviceId)(transport => {
+    return withDevice(
+      deviceId,
+      deviceName ? { matchDeviceByName: deviceName } : undefined,
+    )(transport => {
       if (!isDmkTransport(transport)) {
-        return cmd(transport, { deviceId, request });
+        return cmd(transport, { deviceId, deviceName, request });
       }
       const { dmk, sessionId } = transport;
       const deviceAction = new ConnectAppDeviceAction({

package/src/hw/connectManager.ts

@@ -27,6 +27,7 @@ import { extractOnboardingState, OnboardingStep } from "./extractOnboardingState
 
 export type Input = {
   deviceId: string;
+  deviceName: string | null;
   request: ManagerRequest | null | undefined;
 };
 
@@ -159,13 +160,19 @@ export default function connectManagerFactory(
   } = { isLdmkConnectAppEnabled: false },
 ) {
   if (!isLdmkConnectAppEnabled) {
-    return ({ deviceId, request }: Input): Observable<ConnectManagerEvent> =>
-      withDevice(deviceId)(transport => cmd(transport, { deviceId, request }));
+    return ({ deviceId, deviceName, request }: Input): Observable<ConnectManagerEvent> =>
+      withDevice(
+        deviceId,
+        deviceName ? { matchDeviceByName: deviceName } : undefined,
+      )(transport => cmd(transport, { deviceId, deviceName, request }));
   }
-  return ({ deviceId, request }: Input): Observable<ConnectManagerEvent> =>
-    withDevice(deviceId)(transport => {
+  return ({ deviceId, deviceName, request }: Input): Observable<ConnectManagerEvent> =>
+    withDevice(
+      deviceId,
+      deviceName ? { matchDeviceByName: deviceName } : undefined,
+    )(transport => {
       if (!isDmkTransport(transport)) {
-        return cmd(transport, { deviceId, request });
+        return cmd(transport, { deviceId, deviceName, request });
       }
       const { dmk, sessionId } = transport;
       const deviceAction = new PrepareConnectManagerDeviceAction({
@@ -179,6 +186,6 @@ export default function connectManagerFactory(
       });
       return new PrepareConnectManagerEventMapper(observable)
         .map()
-        .pipe(concatWith(cmd(transport, { deviceId, request })));
+        .pipe(concatWith(cmd(transport, { deviceId, deviceName, request })));
     });
 }

package/src/hw/customLockScreenFetch.ts

@@ -47,13 +47,21 @@ export type FetchImageRequest = {
 
 export type Input = {
   deviceId: string;
+  deviceName: string | null;
   request: FetchImageRequest;
 };
 
-export default function fetchImage({ deviceId, request }: Input): Observable<FetchImageEvent> {
+export default function fetchImage({
+  deviceId,
+  deviceName,
+  request,
+}: Input): Observable<FetchImageEvent> {
   const { backupHash, allowedEmpty = false, deviceModelId } = request;
 
-  const sub = withDevice(deviceId)(
+  const sub = withDevice(
+    deviceId,
+    deviceName ? { matchDeviceByName: deviceName } : undefined,
+  )(
     transport =>
       new Observable(subscriber => {
         const timeoutSub = of<FetchImageEvent>({

package/src/hw/customLockScreenLoad.test.ts

@@ -9,8 +9,12 @@ const mockTransport = {
   send: jest.fn(),
   getTraceContext: jest.fn(),
 };
+const mockWithTransport = jest.fn(
+  (_deviceId: string, _options?: any) => callback =>
+    callback({ transportRef: { current: mockTransport } }),
+);
 jest.mock("../deviceSDK/transports/core", () => ({
-  withTransport: () => callback => callback({ transportRef: { current: mockTransport } }),
+  withTransport: (deviceId: string, options?: any) => mockWithTransport(deviceId, options),
 }));
 jest.mock("./getDeviceInfo", () => jest.fn(() => of([])));
 
@@ -24,7 +28,9 @@ describe("customLockScreenLoad", () => {
     mockTransport.send.mockResolvedValue(Buffer.from([0x42, 0x42, 0x43, 0x90, 0x00]));
 
     // when
-    const ret = await lastValueFrom(await customLockScreenLoad({ deviceId: "deviceId", request }));
+    const ret = await lastValueFrom(
+      await customLockScreenLoad({ deviceId: "deviceId", deviceName: null, request }),
+    );
 
     // then
     expect(mockTransport.send).toHaveBeenNthCalledWith(
@@ -78,9 +84,28 @@ describe("customLockScreenLoad", () => {
 
     // when
     try {
-      await lastValueFrom(await customLockScreenLoad({ deviceId: "nanoX", request }));
+      await lastValueFrom(
+        await customLockScreenLoad({ deviceId: "nanoX", deviceName: null, request }),
+      );
     } catch (err) {
       expect(err).toStrictEqual(error);
     }
   });
+
+  it("should pass deviceName to withTransport", async () => {
+    const request = {
+      deviceModelId: DeviceModelId.stax as CLSSupportedDeviceModelId,
+      hexImage: "hello_world",
+    };
+    mockTransport.send.mockResolvedValue(Buffer.from([0x42, 0x42, 0x43, 0x90, 0x00]));
+
+    await lastValueFrom(
+      await customLockScreenLoad({ deviceId: "deviceId", deviceName: "My Device", request }),
+    );
+
+    expect(mockWithTransport).toHaveBeenCalledWith(
+      "deviceId",
+      expect.objectContaining({ matchDeviceByName: "My Device" }),
+    );
+  });
 });

package/src/hw/customLockScreenLoad.ts

@@ -68,14 +68,22 @@ export type LoadImageRequest = {
 
 export type Input = {
   deviceId: string;
+  deviceName: string | null;
   request: LoadImageRequest;
 };
 
-export default function loadImage({ deviceId, request }: Input): Observable<LoadImageEvent> {
+export default function loadImage({
+  deviceId,
+  deviceName,
+  request,
+}: Input): Observable<LoadImageEvent> {
   const { hexImage, padImage = true, deviceModelId } = request;
   const screenSpecs = getScreenSpecs(deviceModelId);
 
-  const sub = withTransport(deviceId)(
+  const sub = withTransport(
+    deviceId,
+    deviceName ? { matchDeviceByName: deviceName } : undefined,
+  )(
     ({ transportRef }) =>
       new Observable(subscriber => {
         const timeoutSub = of<LoadImageEvent>({ type: "unresponsiveDevice" })

package/src/hw/deviceAccess.ts

@@ -17,7 +17,7 @@ import {
 } from "@ledgerhq/errors";
 import { LocalTracer, TraceContext, trace } from "@ledgerhq/logs";
 import { getEnv } from "@ledgerhq/live-env";
-import { open, close } from ".";
+import { open, close, OpenOptions } from ".";
 
 const LOG_TYPE = "hw";
 
@@ -172,9 +172,10 @@ export class DeviceQueuedJobsManager {
  * @param deviceId
  * @param options contains optional configuration
  *   - openTimeoutMs: optional timeout that limits in time the open attempt of the matching registered transport.
+ *   - matchDeviceByName: optional name of the device to match.
  */
 export const withDevice =
-  (deviceId: string, options?: { openTimeoutMs?: number }) =>
+  (deviceId: string, options?: OpenOptions) =>
   <T>(job: (t: Transport) => Observable<T>): Observable<T> =>
     new Observable(o => {
       const queuedJobManager = DeviceQueuedJobsManager.getInstance();
@@ -221,7 +222,7 @@ export const withDevice =
             previousJobId: previousQueuedJob.id,
             currentJobId: jobId,
           });
-          return open(deviceId, options?.openTimeoutMs, tracer.getContext());
+          return open(deviceId, options, tracer.getContext());
         }) // open the transport
         .then(async transport => {
           tracer.trace("Got a Transport instance from open");

package/src/hw/getGenuineCheckFromDeviceId.test.ts

@@ -85,6 +85,7 @@ describe("getGenuineCheckFromDeviceId", () => {
         let step = 1;
         getGenuineCheckFromDeviceId({
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
           lockedDeviceTimeoutMs: 1000,
         }).subscribe({
           next: ({ socketEvent, lockedDevice }: GetGenuineCheckFromDeviceIdResult) => {
@@ -147,6 +148,7 @@ describe("getGenuineCheckFromDeviceId", () => {
         let step = 1;
         getGenuineCheckFromDeviceId({
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
           lockedDeviceTimeoutMs: 1000,
         }).subscribe({
           next: ({ socketEvent, lockedDevice }: GetGenuineCheckFromDeviceIdResult) => {
@@ -227,6 +229,7 @@ describe("getGenuineCheckFromDeviceId", () => {
         let step = 1;
         const subscriber = getGenuineCheckFromDeviceId({
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
           lockedDeviceTimeoutMs: 1000,
         }).subscribe({
           next: ({ socketEvent, lockedDevice }: GetGenuineCheckFromDeviceIdResult) => {
@@ -286,6 +289,7 @@ describe("getGenuineCheckFromDeviceId", () => {
         let step = 1;
         getGenuineCheckFromDeviceId({
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
           lockedDeviceTimeoutMs: 1000,
         }).subscribe({
           next: ({ socketEvent, lockedDevice }: GetGenuineCheckFromDeviceIdResult) => {

package/src/hw/getGenuineCheckFromDeviceId.ts

@@ -8,6 +8,7 @@ import genuineCheck from "./genuineCheck";
 
 export type GetGenuineCheckFromDeviceIdArgs = {
   deviceId: string;
+  deviceName: string | null;
   lockedDeviceTimeoutMs?: number;
 };
 
@@ -29,6 +30,7 @@ export type GetGenuineCheckFromDeviceIdOutput = Observable<GetGenuineCheckFromDe
  */
 export const getGenuineCheckFromDeviceId = ({
   deviceId,
+  deviceName,
   lockedDeviceTimeoutMs = 1000,
 }: GetGenuineCheckFromDeviceIdArgs): GetGenuineCheckFromDeviceIdOutput => {
   return new Observable(subscriber => {
@@ -42,7 +44,10 @@ export const getGenuineCheckFromDeviceId = ({
 
     // Returns a Subscription that can be unsubscribed/cleaned
     return (
-      withDevice(deviceId)(t =>
+      withDevice(
+        deviceId,
+        deviceName ? { matchDeviceByName: deviceName } : undefined,
+      )(t =>
         from(getDeviceInfo(t)).pipe(
           mergeMap(deviceInfo => {
             clearTimeout(lockedDeviceTimeout);

package/src/hw/getOnboardingStatePolling.test.ts

@@ -79,6 +79,7 @@ describe("getOnboardingStatePolling", () => {
 
         getOnboardingStatePolling({
           deviceId: device.deviceId,
+          deviceName: null,
           pollingPeriodMs,
         }).subscribe({
           next: value => {
@@ -107,6 +108,7 @@ describe("getOnboardingStatePolling", () => {
 
         getOnboardingStatePolling({
           deviceId: device.deviceId,
+          deviceName: null,
           pollingPeriodMs,
         }).subscribe({
           next: value => {
@@ -135,6 +137,7 @@ describe("getOnboardingStatePolling", () => {
 
         getOnboardingStatePolling({
           deviceId: device.deviceId,
+          deviceName: null,
           pollingPeriodMs,
         }).subscribe({
           next: value => {
@@ -164,6 +167,7 @@ describe("getOnboardingStatePolling", () => {
 
         getOnboardingStatePolling({
           deviceId: device.deviceId,
+          deviceName: null,
           pollingPeriodMs,
           safeGuardTimeoutMs,
         }).subscribe({
@@ -192,6 +196,7 @@ describe("getOnboardingStatePolling", () => {
 
         getOnboardingStatePolling({
           deviceId: device.deviceId,
+          deviceName: null,
           pollingPeriodMs,
         }).subscribe({
           error: error => {
@@ -221,6 +226,7 @@ describe("getOnboardingStatePolling", () => {
 
       onboardingStatePollingSubscription = getOnboardingStatePolling({
         deviceId: device.deviceId,
+        deviceName: null,
         pollingPeriodMs,
       }).subscribe({
         next: value => {
@@ -248,6 +254,7 @@ describe("getOnboardingStatePolling", () => {
 
       onboardingStatePollingSubscription = getOnboardingStatePolling({
         deviceId: device.deviceId,
+        deviceName: null,
         pollingPeriodMs,
       }).subscribe({
         next: value => {
@@ -281,6 +288,7 @@ describe("getOnboardingStatePolling", () => {
 
       onboardingStatePollingSubscription = getOnboardingStatePolling({
         deviceId: device.deviceId,
+        deviceName: null,
         pollingPeriodMs,
         safeGuardTimeoutMs: pollingPeriodMs * 10,
       }).subscribe({
@@ -310,6 +318,7 @@ describe("getOnboardingStatePolling", () => {
 
       onboardingStatePollingSubscription = getOnboardingStatePolling({
         deviceId: device.deviceId,
+        deviceName: null,
         pollingPeriodMs,
       }).subscribe({
         next: value => {
@@ -328,4 +337,29 @@ describe("getOnboardingStatePolling", () => {
       jest.advanceTimersByTime(pollingPeriodMs - 1);
     });
   });
+
+  describe("When deviceName is provided", () => {
+    it("should pass deviceName to withDevice", done => {
+      mockedGetVersion.mockResolvedValue(aFirmwareInfo);
+      mockedExtractOnboardingState.mockReturnValue(anOnboardingState);
+
+      const device = aDevice;
+
+      getOnboardingStatePolling({
+        deviceId: device.deviceId,
+        deviceName: "My Device",
+        pollingPeriodMs,
+      }).subscribe({
+        next: () => {
+          expect(mockedWithDevice).toHaveBeenCalledWith(
+            device.deviceId,
+            expect.objectContaining({ matchDeviceByName: "My Device" }),
+          );
+          done();
+        },
+      });
+
+      jest.advanceTimersByTime(pollingPeriodMs - 1);
+    });
+  });
 });