@ledgerhq/live-common 34.35.0-nightly.3 → 34.35.0-nightly.5

package/src/hw/connectAppEventMapper.ts

@@ -0,0 +1,364 @@
+import { Observable, Subject, of, share, takeUntil } from "rxjs";
+import { catchError, tap, withLatestFrom } from "rxjs/operators";
+import type {
+  DeviceManagementKit,
+  DeviceActionState,
+  InstallPlan,
+  ExecuteDeviceActionReturnType,
+  DeviceSessionState,
+  GetOsVersionResponse,
+  FirmwareUpdateContext as DmkFirmwareUpdateContext,
+} from "@ledgerhq/device-management-kit";
+import {
+  DeviceActionStatus,
+  DeviceLockedError,
+  DeviceSessionStateType,
+  DeviceStatus,
+  UserInteractionRequired,
+  OutOfMemoryDAError,
+  SecureChannelError,
+  UnsupportedFirmwareDAError,
+} from "@ledgerhq/device-management-kit";
+import type {
+  ConnectAppDAOutput,
+  ConnectAppDAError,
+  ConnectAppDAIntermediateValue,
+} from "@ledgerhq/live-dmk-shared";
+import { DeviceInfo, FirmwareUpdateContext } from "@ledgerhq/types-live";
+import {
+  UserRefusedAllowManager,
+  UserRefusedOnDevice,
+  LatestFirmwareVersionRequired,
+} from "@ledgerhq/errors";
+
+import type { SkippedAppOp } from "../apps/types";
+import { SkipReason } from "../apps/types";
+import { parseDeviceInfo } from "../deviceSDK/tasks/getDeviceInfo";
+import { ConnectAppEvent } from "./connectApp";
+
+export class ConnectAppEventMapper {
+  private openAppRequested: boolean = false;
+  private permissionRequested: boolean = false;
+  private lastSeenDeviceSent: boolean = false;
+  private installPlan: InstallPlan | null = null;
+  private eventSubject = new Subject<ConnectAppEvent>();
+
+  constructor(
+    private dmk: DeviceManagementKit,
+    private sessionId: string,
+    private appName: string,
+    private events: ExecuteDeviceActionReturnType<
+      ConnectAppDAOutput,
+      ConnectAppDAError,
+      ConnectAppDAIntermediateValue
+    >,
+  ) {}
+
+  map(): Observable<ConnectAppEvent> {
+    const cancelAction = this.events.cancel;
+    const unsubscribe = new Subject<void>();
+
+    // Create a shared observable for device session state
+    const deviceSessionState = this.dmk
+      .getDeviceSessionState({ sessionId: this.sessionId })
+      .pipe(share());
+
+    // Subscribe to device action events
+    this.events.observable
+      .pipe(
+        withLatestFrom(deviceSessionState),
+        tap(([event, deviceState]) => this.handleEvent(event, deviceState)),
+        takeUntil(unsubscribe),
+        catchError(error => this.handleError(error)),
+      )
+      .subscribe();
+
+    // Subscribe to device session state events
+    deviceSessionState
+      .pipe(
+        tap(deviceState => this.handleDeviceState(deviceState)),
+        takeUntil(unsubscribe),
+      )
+      .subscribe();
+
+    return new Observable<ConnectAppEvent>(observer => {
+      const sub = this.eventSubject.subscribe(observer);
+      return () => {
+        sub.unsubscribe();
+        cancelAction();
+        unsubscribe.next();
+      };
+    });
+  }
+
+  private handleDeviceState(deviceState: DeviceSessionState): void {
+    if (deviceState.sessionStateType === DeviceSessionStateType.Connected) {
+      return;
+    }
+
+    if (deviceState.deviceStatus === DeviceStatus.NOT_CONNECTED) {
+      this.eventSubject.next({ type: "disconnected", expected: false });
+    } else if (
+      deviceState.firmwareVersion?.metadata &&
+      deviceState.firmwareUpdateContext &&
+      !this.lastSeenDeviceSent
+    ) {
+      this.lastSeenDeviceSent = true;
+      this.eventSubject.next({
+        type: "device-update-last-seen",
+        deviceInfo: this.mapDeviceInfo(deviceState.firmwareVersion.metadata),
+        latestFirmware: this.mapLatestFirmware(deviceState.firmwareUpdateContext),
+      });
+    }
+  }
+
+  private handleEvent(
+    event: DeviceActionState<ConnectAppDAOutput, ConnectAppDAError, ConnectAppDAIntermediateValue>,
+    deviceState: DeviceSessionState,
+  ): void {
+    switch (event.status) {
+      case DeviceActionStatus.Pending:
+        this.handlePendingEvent(event.intermediateValue);
+        break;
+      case DeviceActionStatus.Completed:
+        this.handleCompletedEvent(event.output, deviceState);
+        break;
+      case DeviceActionStatus.Error:
+        this.handleErrorEvent(event.error, deviceState);
+        break;
+      case DeviceActionStatus.NotStarted:
+      case DeviceActionStatus.Stopped:
+        this.eventSubject.error(new Error("Unexpected device action status"));
+        break;
+    }
+  }
+
+  private handlePendingEvent(intermediateValue: ConnectAppDAIntermediateValue): void {
+    switch (intermediateValue.requiredUserInteraction) {
+      case UserInteractionRequired.ConfirmOpenApp:
+        if (!this.openAppRequested) {
+          this.openAppRequested = true;
+          this.eventSubject.next({ type: "ask-open-app", appName: this.appName });
+        }
+        break;
+      case UserInteractionRequired.AllowSecureConnection:
+        if (!this.permissionRequested) {
+          this.permissionRequested = true;
+          this.eventSubject.next({ type: "device-permission-requested" });
+        }
+        break;
+      case UserInteractionRequired.UnlockDevice:
+        this.eventSubject.next({ type: "lockedDevice" });
+        break;
+      case UserInteractionRequired.None:
+        if (this.openAppRequested) {
+          this.openAppRequested = false;
+          this.eventSubject.next({ type: "device-permission-granted" });
+        }
+        if (this.permissionRequested) {
+          this.permissionRequested = false;
+          this.eventSubject.next({ type: "device-permission-granted" });
+
+          // Simulate apps listing (not systematic step in LDMK)
+          this.eventSubject.next({ type: "listing-apps" });
+        }
+        if (intermediateValue.installPlan !== null) {
+          this.handleInstallPlan(intermediateValue.installPlan);
+        }
+        break;
+    }
+  }
+
+  private handleInstallPlan(installPlan: InstallPlan): void {
+    // Handle install plan resolved events
+    if (this.installPlan === null) {
+      // Skipped applications
+      const alreadyInstalled = this.mapSkippedApps(
+        installPlan.alreadyInstalled,
+        SkipReason.AppAlreadyInstalled,
+      );
+      const missing = this.mapSkippedApps(
+        installPlan.missingApplications,
+        SkipReason.NoSuchAppOnProvider,
+      );
+      const skippedAppOps = [...alreadyInstalled, ...missing];
+      if (skippedAppOps.length > 0) {
+        this.eventSubject.next({
+          type: "some-apps-skipped",
+          skippedAppOps,
+        });
+      }
+
+      // Install queue content
+      this.eventSubject.next({
+        type: "listed-apps",
+        installQueue: installPlan.installPlan.map(app => app.versionName),
+      });
+    }
+
+    // Handle ongoing install events
+    this.eventSubject.next({
+      type: "inline-install",
+      progress: installPlan.currentProgress,
+      itemProgress: installPlan.currentIndex,
+      currentAppOp: {
+        type: "install",
+        name: installPlan.installPlan[installPlan.currentIndex]!.versionName,
+      },
+      installQueue: installPlan.installPlan.map(app => app.versionName),
+    });
+    this.installPlan = installPlan;
+  }
+
+  private handleCompletedEvent(output: ConnectAppDAOutput, deviceState: DeviceSessionState): void {
+    if (deviceState.sessionStateType !== DeviceSessionStateType.Connected) {
+      // Handle opened app
+      const currentApp = deviceState.currentApp;
+      let flags: number | Buffer = 0;
+      if (typeof currentApp.flags === "number") {
+        flags = currentApp.flags;
+      } else if (currentApp.flags !== undefined) {
+        flags = Buffer.from(currentApp.flags);
+      }
+      this.eventSubject.next({
+        type: "opened",
+        app: {
+          name: currentApp.name,
+          version: currentApp.version,
+          flags,
+        },
+        derivation: output.derivation ? { address: output.derivation } : undefined,
+      });
+    }
+    this.eventSubject.complete();
+  }
+
+  private handleErrorEvent(error: ConnectAppDAError, deviceState: DeviceSessionState): void {
+    if (error instanceof OutOfMemoryDAError && this.installPlan !== null) {
+      const appNames = this.installPlan.installPlan.map(app => app.versionName);
+      this.eventSubject.next({
+        type: "app-not-installed",
+        appNames,
+        appName: appNames[0]!,
+      });
+      this.eventSubject.complete();
+    } else if (
+      error instanceof UnsupportedFirmwareDAError &&
+      deviceState.sessionStateType !== DeviceSessionStateType.Connected
+    ) {
+      this.eventSubject.error(
+        new LatestFirmwareVersionRequired("LatestFirmwareVersionRequired", {
+          current: deviceState.firmwareUpdateContext!.currentFirmware.version,
+          latest:
+            deviceState.firmwareUpdateContext?.availableUpdate?.finalFirmware.version ||
+            deviceState.firmwareUpdateContext!.currentFirmware.version,
+        }),
+      );
+    } else if (error instanceof DeviceLockedError) {
+      this.eventSubject.next({ type: "lockedDevice" });
+      this.eventSubject.complete();
+    } else if (error instanceof SecureChannelError) {
+      this.eventSubject.error(new UserRefusedAllowManager());
+    } else if ("_tag" in error && error._tag === "WebHidSendReportError") {
+      this.eventSubject.next({ type: "disconnected", expected: false });
+      this.eventSubject.complete();
+    } else if ("errorCode" in error && typeof error.errorCode === "string" && "_tag" in error) {
+      this.eventSubject.error(this.mapDeviceError(error.errorCode, error._tag));
+    } else {
+      this.eventSubject.error(error);
+    }
+  }
+
+  private handleError(error: Error): Observable<never> {
+    this.eventSubject.error(error);
+    return of();
+  }
+
+  private mapDeviceError(errorCode: string, defaultMessage: string): Error {
+    switch (errorCode) {
+      case "5501":
+        return new UserRefusedOnDevice();
+      default:
+        return new Error(defaultMessage);
+    }
+  }
+
+  private mapSkippedApps(appNames: string[], reason: SkipReason): SkippedAppOp[] {
+    return appNames.map(name => ({
+      reason,
+      appOp: {
+        type: "install",
+        name,
+      },
+    }));
+  }
+
+  private mapDeviceInfo(osVersion: GetOsVersionResponse): DeviceInfo {
+    return parseDeviceInfo({
+      isBootloader: osVersion.isBootloader,
+      rawVersion: osVersion.seVersion, // Always the SE version since at this step we cannot be in bootloader mode
+      targetId: osVersion.targetId,
+      seVersion: osVersion.seVersion,
+      seTargetId: osVersion.seTargetId,
+      mcuBlVersion: undefined, // We cannot be in bootloader mode at this step
+      mcuVersion: osVersion.mcuSephVersion,
+      mcuTargetId: osVersion.mcuTargetId,
+      flags: Buffer.from(osVersion.seFlags),
+      bootloaderVersion: osVersion.mcuBootloaderVersion,
+      hardwareVersion: parseInt(osVersion.hwVersion, 16),
+      languageId: osVersion.langId,
+    });
+  }
+
+  private mapLatestFirmware(updateContext: DmkFirmwareUpdateContext): FirmwareUpdateContext | null {
+    if (!updateContext.availableUpdate) {
+      return null;
+    }
+    const availableUpdate = updateContext.availableUpdate;
+    const osu = availableUpdate.osuFirmware;
+    const final = availableUpdate.finalFirmware;
+    return {
+      osu: {
+        id: osu.id,
+        perso: osu.perso,
+        firmware: osu.firmware,
+        firmware_key: osu.firmwareKey,
+        hash: osu.hash || "",
+        next_se_firmware_final_version: osu.nextFinalFirmware,
+        // Following fields are inherited from dto, but unused
+        description: undefined,
+        display_name: undefined,
+        notes: undefined,
+        name: "",
+        date_creation: "",
+        date_last_modified: "",
+        device_versions: [],
+        providers: [],
+        previous_se_firmware_final_version: [],
+      },
+      final: {
+        id: final.id,
+        name: final.version,
+        version: final.version,
+        perso: final.perso,
+        firmware: final.firmware || "",
+        firmware_key: final.firmwareKey || "",
+        hash: final.hash || "",
+        bytes: final.bytes || 0,
+        mcu_versions: final.mcuVersions,
+        // Following fields are inherited from dto, but unused
+        description: undefined,
+        display_name: undefined,
+        notes: undefined,
+        se_firmware: 0,
+        date_creation: "",
+        date_last_modified: "",
+        device_versions: [],
+        application_versions: [],
+        osu_versions: [],
+        providers: [],
+      },
+      shouldFlashMCU: availableUpdate.mcuUpdateRequired,
+    };
+  }
+}

package/src/hw/connectManager.ts

@@ -1,4 +1,4 @@
-import { Observable, concat, from, of, throwError } from "rxjs";
+import { Observable, concat, concatWith, from, of, throwError } from "rxjs";
 import { concatMap, catchError, delay } from "rxjs/operators";
 import {
   TransportStatusError,
@@ -7,6 +7,9 @@ import {
   LockedDeviceError,
 } from "@ledgerhq/errors";
 import { DeviceInfo } from "@ledgerhq/types-live";
+import type Transport from "@ledgerhq/hw-transport";
+import type { DeviceManagementKit } from "@ledgerhq/device-management-kit";
+import { PrepareConnectManagerDeviceAction } from "@ledgerhq/live-dmk-shared";
 import type { ListAppsEvent } from "../apps";
 import { listAppsUseCase } from "../device/use-cases/listAppsUseCase";
 import { withDevice } from "./deviceAccess";
@@ -17,6 +20,7 @@ import { DeviceNotOnboarded } from "../errors";
 import attemptToQuitApp, { AttemptToQuitAppEvent } from "./attemptToQuitApp";
 import { LockedDeviceEvent } from "./actions/types";
 import { ManagerRequest } from "./actions/manager";
+import { PrepareConnectManagerEventMapper } from "./connectManagerEventMapper";
 
 export type Input = {
   deviceId: string;
@@ -40,85 +44,123 @@ export type ConnectManagerEvent =
   | ListAppsEvent
   | LockedDeviceEvent;
 
-const cmd = ({ deviceId, request }: Input): Observable<ConnectManagerEvent> =>
-  withDevice(deviceId)(
-    transport =>
-      new Observable(o => {
-        const timeoutSub = of({
-          type: "unresponsiveDevice",
-        } as ConnectManagerEvent)
-          .pipe(delay(1000))
-          .subscribe(e => o.next(e));
+const cmd = (transport: Transport, { request }: Input): Observable<ConnectManagerEvent> =>
+  new Observable(o => {
+    const timeoutSub = of({
+      type: "unresponsiveDevice",
+    } as ConnectManagerEvent)
+      .pipe(delay(1000))
+      .subscribe(e => o.next(e));
 
-        const sub = from(getDeviceInfo(transport))
-          .pipe(
-            concatMap(deviceInfo => {
-              timeoutSub.unsubscribe();
+    const sub = from(getDeviceInfo(transport))
+      .pipe(
+        concatMap(deviceInfo => {
+          timeoutSub.unsubscribe();
 
-              if (!deviceInfo.onboarded && !deviceInfo.isRecoveryMode) {
-                throw new DeviceNotOnboarded();
-              }
+          if (!deviceInfo.onboarded && !deviceInfo.isRecoveryMode) {
+            throw new DeviceNotOnboarded();
+          }
 
-              if (deviceInfo.isBootloader) {
-                return of({
-                  type: "bootloader",
-                  deviceInfo,
-                } as ConnectManagerEvent);
-              }
+          if (deviceInfo.isBootloader) {
+            return of({
+              type: "bootloader",
+              deviceInfo,
+            } as ConnectManagerEvent);
+          }
 
-              if (deviceInfo.isOSU) {
-                return of({
-                  type: "osu",
-                  deviceInfo,
-                } as ConnectManagerEvent);
-              }
+          if (deviceInfo.isOSU) {
+            return of({
+              type: "osu",
+              deviceInfo,
+            } as ConnectManagerEvent);
+          }
 
-              return concat(
-                of({
-                  type: "listingApps",
-                  deviceInfo,
-                } as ConnectManagerEvent),
-                listAppsUseCase(transport, deviceInfo),
-              );
-            }),
-            catchError((e: unknown) => {
-              if (e instanceof LockedDeviceError) {
-                return of({
-                  type: "lockedDevice",
-                } as ConnectManagerEvent);
-              } else if (
-                e instanceof DeviceOnDashboardExpected ||
-                (e &&
-                  e instanceof TransportStatusError &&
-                  [
-                    StatusCodes.CLA_NOT_SUPPORTED,
-                    StatusCodes.INS_NOT_SUPPORTED,
-                    StatusCodes.UNKNOWN_APDU,
-                    0x6e01, // No StatusCodes definition
-                    0x6d01, // No StatusCodes definition
-                  ].includes(e.statusCode))
-              ) {
-                return from(getAppAndVersion(transport)).pipe(
-                  concatMap(appAndVersion => {
-                    return !request?.autoQuitAppDisabled && !isDashboardName(appAndVersion.name)
-                      ? attemptToQuitApp(transport, appAndVersion)
-                      : of({
-                          type: "appDetected",
-                        } as ConnectManagerEvent);
-                  }),
-                );
-              }
+          return concat(
+            of({
+              type: "listingApps",
+              deviceInfo,
+            } as ConnectManagerEvent),
+            listAppsUseCase(transport, deviceInfo),
+          );
+        }),
+        catchError((e: unknown) => {
+          if (e instanceof LockedDeviceError) {
+            return of({
+              type: "lockedDevice",
+            } as ConnectManagerEvent);
+          } else if (
+            e instanceof DeviceOnDashboardExpected ||
+            (e &&
+              e instanceof TransportStatusError &&
+              [
+                StatusCodes.CLA_NOT_SUPPORTED,
+                StatusCodes.INS_NOT_SUPPORTED,
+                StatusCodes.UNKNOWN_APDU,
+                0x6e01, // No StatusCodes definition
+                0x6d01, // No StatusCodes definition
+              ].includes(e.statusCode))
+          ) {
+            return from(getAppAndVersion(transport)).pipe(
+              concatMap(appAndVersion => {
+                return !request?.autoQuitAppDisabled && !isDashboardName(appAndVersion.name)
+                  ? attemptToQuitApp(transport, appAndVersion)
+                  : of({
+                      type: "appDetected",
+                    } as ConnectManagerEvent);
+              }),
+            );
+          }
 
-              return throwError(() => e);
-            }),
-          )
-          .subscribe(o);
+          return throwError(() => e);
+        }),
+      )
+      .subscribe(o);
 
-        return () => {
-          timeoutSub.unsubscribe();
-          sub.unsubscribe();
-        };
-      }),
+    return () => {
+      timeoutSub.unsubscribe();
+      sub.unsubscribe();
+    };
+  });
+
+const isDmkTransport = (
+  transport: Transport,
+): transport is Transport & { dmk: DeviceManagementKit; sessionId: string } => {
+  return (
+    "dmk" in transport &&
+    transport.dmk !== undefined &&
+    "sessionId" in transport &&
+    transport.sessionId !== undefined
   );
+};
 
-export default cmd;
+export default function connectManagerFactory(
+  {
+    isLdmkConnectAppEnabled,
+  }: {
+    isLdmkConnectAppEnabled: boolean;
+  } = { isLdmkConnectAppEnabled: false },
+) {
+  if (!isLdmkConnectAppEnabled) {
+    return ({ deviceId, request }: Input): Observable<ConnectManagerEvent> =>
+      withDevice(deviceId)(transport => cmd(transport, { deviceId, request }));
+  }
+  return ({ deviceId, request }: Input): Observable<ConnectManagerEvent> =>
+    withDevice(deviceId)(transport => {
+      if (!isDmkTransport(transport)) {
+        return cmd(transport, { deviceId, request });
+      }
+      const { dmk, sessionId } = transport;
+      const deviceAction = new PrepareConnectManagerDeviceAction({
+        input: {
+          unlockTimeout: 0, // Expect to fail immediately when device is locked
+        },
+      });
+      const observable = dmk.executeDeviceAction({
+        sessionId,
+        deviceAction,
+      });
+      return new PrepareConnectManagerEventMapper(observable)
+        .map()
+        .pipe(concatWith(cmd(transport, { deviceId, request })));
+    });
+}

package/src/hw/connectManagerEventMapper.ts

@@ -0,0 +1,109 @@
+import { Observable, Subject, of, takeUntil } from "rxjs";
+import { catchError, tap } from "rxjs/operators";
+import type {
+  DeviceActionState,
+  ExecuteDeviceActionReturnType,
+} from "@ledgerhq/device-management-kit";
+import {
+  DeviceActionStatus,
+  DeviceLockedError,
+  UserInteractionRequired,
+} from "@ledgerhq/device-management-kit";
+import type {
+  PrepareConnectManagerDAOutput,
+  PrepareConnectManagerDAError,
+  PrepareConnectManagerDAIntermediateValue,
+} from "@ledgerhq/live-dmk-shared";
+import { DisconnectedDevice } from "@ledgerhq/errors";
+
+import { LockedDeviceEvent } from "./actions/types";
+
+export class PrepareConnectManagerEventMapper {
+  private eventSubject = new Subject<LockedDeviceEvent>();
+
+  constructor(
+    private events: ExecuteDeviceActionReturnType<
+      PrepareConnectManagerDAOutput,
+      PrepareConnectManagerDAError,
+      PrepareConnectManagerDAIntermediateValue
+    >,
+  ) {}
+
+  map(): Observable<LockedDeviceEvent> {
+    const cancelAction = this.events.cancel;
+    const unsubscribe = new Subject<void>();
+
+    // Subscribe to device action events
+    this.events.observable
+      .pipe(
+        tap(event => this.handleEvent(event)),
+        takeUntil(unsubscribe),
+        catchError(error => this.handleError(error)),
+      )
+      .subscribe();
+
+    return new Observable<LockedDeviceEvent>(observer => {
+      const sub = this.eventSubject.subscribe(observer);
+      return () => {
+        sub.unsubscribe();
+        cancelAction();
+        unsubscribe.next();
+      };
+    });
+  }
+
+  private handleEvent(
+    event: DeviceActionState<
+      PrepareConnectManagerDAOutput,
+      PrepareConnectManagerDAError,
+      PrepareConnectManagerDAIntermediateValue
+    >,
+  ): void {
+    switch (event.status) {
+      case DeviceActionStatus.Pending:
+        this.handlePendingEvent(event.intermediateValue);
+        break;
+      case DeviceActionStatus.Completed:
+        this.handleCompletedEvent(event.output);
+        break;
+      case DeviceActionStatus.Error:
+        this.handleErrorEvent(event.error);
+        break;
+      case DeviceActionStatus.NotStarted:
+      case DeviceActionStatus.Stopped:
+        this.eventSubject.error(new Error("Unexpected device action status"));
+        break;
+    }
+  }
+
+  private handlePendingEvent(intermediateValue: PrepareConnectManagerDAIntermediateValue): void {
+    switch (intermediateValue.requiredUserInteraction) {
+      case UserInteractionRequired.UnlockDevice:
+        this.eventSubject.next({ type: "lockedDevice" });
+        break;
+      case UserInteractionRequired.None:
+        // Nothing to do
+        break;
+    }
+  }
+
+  private handleCompletedEvent(_output: PrepareConnectManagerDAOutput): void {
+    this.eventSubject.complete();
+  }
+
+  private handleErrorEvent(error: PrepareConnectManagerDAError): void {
+    if (error instanceof DeviceLockedError) {
+      this.eventSubject.next({ type: "lockedDevice" });
+      this.eventSubject.complete();
+    } else if ("_tag" in error && error._tag === "WebHidSendReportError") {
+      this.eventSubject.error(new DisconnectedDevice());
+    } else {
+      this.eventSubject.error(error);
+    }
+  }
+
+  private handleError(error: Error): Observable<never> {
+    this.eventSubject.error(error);
+    return of();
+  }
+}