@ledgerhq/live-common 26.0.0 → 26.1.0-next.1

package/src/hw/getVersion.ts

@@ -1,9 +1,42 @@
+import { DeviceModelId, identifyTargetId } from "@ledgerhq/devices";
 import Transport from "@ledgerhq/hw-transport";
 import type { FirmwareInfo } from "@ledgerhq/types-live";
+import { satisfies as versionSatisfies } from "semver";
+import { isDeviceLocalizationSupported } from "../manager/localization";
 
-/**
- * Retrieve targetId and firmware version from device
- */
+const deviceVersionRangesForBootloaderVersion: {
+  [key in DeviceModelId]?: string;
+} = {
+  nanoS: ">=2.0.0",
+  nanoX: ">=2.0.0 || =2.1.0-lo2 || =2.1.0-lo4 || =2.1.0-lo5", // TODO: remove pre-release version
+  nanoSP: ">=1.0.0",
+};
+export const isBootloaderVersionSupported = (
+  seVersion: string,
+  modelId?: DeviceModelId
+) =>
+  modelId &&
+  deviceVersionRangesForBootloaderVersion[modelId] &&
+  versionSatisfies(
+    seVersion,
+    deviceVersionRangesForBootloaderVersion[modelId] as string
+  );
+
+const deviceVersionRangesForHardwareVersion: {
+  [key in DeviceModelId]?: string;
+} = {
+  nanoX: ">=2.0.0 || =2.1.0-lo2 || =2.1.0-lo4 || =2.1.0-lo5", // TODO: remove pre-release version
+};
+export const isHardwareVersionSupported = (
+  seVersion: string,
+  modelId?: DeviceModelId
+) =>
+  modelId &&
+  deviceVersionRangesForHardwareVersion[modelId] &&
+  versionSatisfies(
+    seVersion,
+    deviceVersionRangesForHardwareVersion[modelId] as string
+  );
 
 export default async function getVersion(
   transport: Transport
@@ -35,8 +68,11 @@ export default async function getVersion(
   let mcuVersion = "";
   let mcuBlVersion: string | undefined;
   let seVersion: string | undefined;
+  let bootloaderVersion: string | undefined;
+  let hardwareVersion: number | undefined;
   let mcuTargetId: number | undefined;
   let seTargetId: number | undefined;
+  let languageId: number | undefined;
 
   const isBootloader = (targetId & 0xf0000000) !== 0x30000000;
 
@@ -77,6 +113,41 @@ export default async function getVersion(
       mcuVersionBuf = mcuVersionBuf.slice(0, mcuVersionBuf.length - 1);
     }
     mcuVersion = mcuVersionBuf.toString();
+
+    const isOSU = rawVersion.includes("-osu");
+
+    if (!isOSU) {
+      const deviceModel = identifyTargetId(targetId);
+
+      if (isBootloaderVersionSupported(seVersion, deviceModel?.id)) {
+        const bootloaderVersionLength = data[i++];
+        let bootloaderVersionBuf: Buffer = Buffer.from(
+          data.slice(i, i + bootloaderVersionLength)
+        );
+        i += bootloaderVersionLength;
+
+        if (bootloaderVersionBuf[bootloaderVersionBuf.length - 1] === 0) {
+          bootloaderVersionBuf = bootloaderVersionBuf.slice(
+            0,
+            bootloaderVersionBuf.length - 1
+          );
+        }
+        bootloaderVersion = bootloaderVersionBuf.toString();
+      }
+
+      if (isHardwareVersionSupported(seVersion, deviceModel?.id)) {
+        const hardwareVersionLength = data[i++];
+        hardwareVersion = data
+          .slice(i, i + hardwareVersionLength)
+          .readUIntBE(0, 1); // ?? string? number?
+        i += hardwareVersionLength;
+      }
+
+      if (isDeviceLocalizationSupported(seVersion, deviceModel?.id)) {
+        const languageIdLength = data[i++];
+        languageId = data.slice(i, i + languageIdLength).readUIntBE(0, 1);
+      }
+    }
   }
 
   return {
@@ -89,5 +160,8 @@ export default async function getVersion(
     mcuTargetId,
     seTargetId,
     flags,
+    bootloaderVersion,
+    hardwareVersion,
+    languageId,
   };
 }

package/src/hw/installLanguage.ts

@@ -0,0 +1,172 @@
+import { Observable, from, of, throwError } from "rxjs";
+import { catchError, concatMap, delay, mergeMap } from "rxjs/operators";
+import {
+  DeviceOnDashboardExpected,
+  TransportError,
+  TransportStatusError,
+  LanguageNotFound,
+} from "@ledgerhq/errors";
+
+import ManagerAPI from "../api/Manager";
+import { withDevice } from "./deviceAccess";
+import getDeviceInfo from "./getDeviceInfo";
+import { Language, LanguagePackage } from "@ledgerhq/types-live";
+import network from "../network";
+import { LanguageInstallRefusedOnDevice } from "../errors";
+import getAppAndVersion from "./getAppAndVersion";
+import { isDashboardName } from "./isDashboardName";
+import Transport from "@ledgerhq/hw-transport";
+import attemptToQuitApp, { AttemptToQuitAppEvent } from "./attemptToQuitApp";
+
+export type InstallLanguageEvent =
+  | AttemptToQuitAppEvent
+  | {
+      type: "progress";
+      progress: number;
+    }
+  | {
+      type: "devicePermissionRequested";
+    }
+  | {
+      type: "languageInstalled";
+    };
+
+export type InstallLanguageRequest = {
+  deviceId: string;
+  language: Language;
+};
+
+export default function installLanguage({
+  deviceId,
+  language,
+}: InstallLanguageRequest): Observable<InstallLanguageEvent> {
+  const sub = withDevice(deviceId)(
+    (transport) =>
+      new Observable((subscriber) => {
+        const timeoutSub = of<InstallLanguageEvent>({
+          type: "unresponsiveDevice",
+        })
+          .pipe(delay(1000))
+          .subscribe((e) => subscriber.next(e));
+
+        const sub = from(getDeviceInfo(transport))
+          .pipe(
+            mergeMap(async (deviceInfo) => {
+              timeoutSub.unsubscribe();
+
+              if (language === "english") {
+                await uninstallAllLanguages(transport);
+
+                subscriber.next({
+                  type: "languageInstalled",
+                });
+                subscriber.complete();
+
+                return;
+              }
+
+              const languages = await ManagerAPI.getLanguagePackagesForDevice(
+                deviceInfo
+              );
+
+              const packs: LanguagePackage[] = languages.filter(
+                (l: any) => l.language === language
+              );
+
+              if (!packs.length)
+                return subscriber.error(new LanguageNotFound(language));
+
+              const pack = packs[0];
+              const { apdu_install_url } = pack;
+              const url = apdu_install_url;
+
+              const { data: rawApdus } = await network({
+                method: "GET",
+                url,
+              });
+
+              const apdus = rawApdus.split(/\r?\n/).filter(Boolean);
+
+              await uninstallAllLanguages(transport);
+
+              for (let i = 0; i < apdus.length; i++) {
+                if (apdus[i].startsWith("e030")) {
+                  subscriber.next({
+                    type: "devicePermissionRequested",
+                  });
+                }
+
+                const response = await transport.exchange(
+                  Buffer.from(apdus[i], "hex")
+                );
+                const status = response.readUInt16BE(response.length - 2);
+                const statusStr = status.toString(16);
+
+                // Some error handling
+                if (status === 0x5501) {
+                  return subscriber.error(
+                    new LanguageInstallRefusedOnDevice(statusStr)
+                  );
+                } else if (status !== 0x9000) {
+                  return subscriber.error(
+                    new TransportError("Unexpected device response", statusStr)
+                  );
+                }
+
+                subscriber.next({
+                  type: "progress",
+                  progress: (i + 1) / apdus.length,
+                });
+              }
+
+              subscriber.next({
+                type: "languageInstalled",
+              });
+
+              subscriber.complete();
+            }),
+            catchError((e: Error) => {
+              if (
+                e instanceof DeviceOnDashboardExpected ||
+                (e &&
+                  e instanceof TransportStatusError &&
+                  [0x6e00, 0x6d00, 0x6e01, 0x6d01, 0x6d02].includes(
+                    // @ts-expect-error typescript not checking agains the instanceof
+                    e.statusCode
+                  ))
+              ) {
+                return from(getAppAndVersion(transport)).pipe(
+                  concatMap((appAndVersion) => {
+                    return !isDashboardName(appAndVersion.name)
+                      ? attemptToQuitApp(transport, appAndVersion)
+                      : of<InstallLanguageEvent>({
+                          type: "appDetected",
+                        });
+                  })
+                );
+              }
+              return throwError(e);
+            })
+          )
+          .subscribe(subscriber);
+
+        return () => {
+          timeoutSub.unsubscribe();
+          sub.unsubscribe();
+        };
+      })
+  );
+
+  return sub as Observable<InstallLanguageEvent>;
+}
+
+const uninstallAllLanguages = async (transport: Transport) => {
+  await transport.send(
+    0xe0,
+    0x33,
+    0xff,
+    0x00,
+    undefined,
+    [0x9000, 0x5501] // Expected responses when uninstalling.
+  );
+};

package/src/hw/uninstallLanguage.ts

@@ -0,0 +1,127 @@
+import { Observable, from, of, throwError, EMPTY } from "rxjs";
+import { catchError, concatMap, delay, mergeMap } from "rxjs/operators";
+import {
+  DeviceOnDashboardExpected,
+  TransportStatusError,
+} from "@ledgerhq/errors";
+
+import { withDevice } from "./deviceAccess";
+import getDeviceInfo from "./getDeviceInfo";
+import { Language, languageIds } from "@ledgerhq/types-live";
+import { AppAndVersion } from "./connectApp";
+import appSupportsQuitApp from "../appSupportsQuitApp";
+import quitApp from "./quitApp";
+import getAppAndVersion from "./getAppAndVersion";
+import { isDashboardName } from "./isDashboardName";
+
+export type UninstallLanguageEvent =
+  | {
+      type: "appDetected";
+    }
+  | {
+      type: "unresponsiveDevice";
+    }
+  | {
+      type: "languageUninstalled";
+    };
+
+const attemptToQuitApp = (
+  transport,
+  appAndVersion?: AppAndVersion
+): Observable<UninstallLanguageEvent> =>
+  appAndVersion && appSupportsQuitApp(appAndVersion)
+    ? from(quitApp(transport)).pipe(
+        concatMap(() =>
+          of(<UninstallLanguageEvent>{
+            type: "unresponsiveDevice",
+          })
+        ),
+        catchError((e) => throwError(e))
+      )
+    : of({
+        type: "appDetected",
+      });
+
+export type UninstallLanguageRequest = {
+  deviceId: string;
+  language: Language;
+};
+
+export default function unistallLanguage({
+  deviceId,
+  language,
+}: UninstallLanguageRequest): Observable<UninstallLanguageEvent> {
+  const sub = withDevice(deviceId)(
+    (transport) =>
+      new Observable<UninstallLanguageEvent>((subscriber) => {
+        const timeoutSub = of<UninstallLanguageEvent>({
+          type: "unresponsiveDevice",
+        })
+          .pipe(delay(1000))
+          .subscribe((e) => subscriber.next(e));
+
+        const sub = from(getDeviceInfo(transport))
+          .pipe(
+            mergeMap(async (_) => {
+              timeoutSub.unsubscribe();
+
+              const id = languageIds[language];
+
+              await transport.send(
+                0xe0,
+                0x33,
+                id,
+                0x00,
+                undefined,
+                [0x9000, 0x5501] // Expected responses when uninstalling.
+              );
+
+              subscriber.next({
+                type: "languageUninstalled",
+              });
+
+              subscriber.complete();
+            }),
+            catchError((e: Error) => {
+              if (
+                e instanceof DeviceOnDashboardExpected ||
+                (e &&
+                  e instanceof TransportStatusError &&
+                  [0x6e00, 0x6d00, 0x6e01, 0x6d01, 0x6d02].includes(
+                    // @ts-expect-error typescript not checking agains the instanceof
+                    e.statusCode
+                  ))
+              ) {
+                const quitAppObservable = from(
+                  getAppAndVersion(transport)
+                ).pipe(
+                  concatMap((appAndVersion) => {
+                    return !isDashboardName(appAndVersion.name)
+                      ? attemptToQuitApp(transport, appAndVersion)
+                      : of<UninstallLanguageEvent>({
+                          type: "appDetected",
+                        });
+                  })
+                );
+
+                quitAppObservable.subscribe(
+                  (event) => subscriber.next(event),
+                  (error) => subscriber.error(error)
+                );
+              }
+
+              subscriber.error(e);
+              return EMPTY;
+            })
+          )
+          .subscribe();
+
+        return () => {
+          timeoutSub.unsubscribe();
+          sub.unsubscribe();
+        };
+      })
+  );
+
+  return sub;
+}

package/src/manager/hooks.ts

@@ -4,7 +4,11 @@ import { useEnv } from "../env.react";
 import manager from ".";
 import { getProviderId } from "./provider";
 import ManagerAPI from "../api/Manager";
-import type { DeviceModelInfo } from "@ledgerhq/types-live";
+import type {
+  DeviceModelInfo,
+  DeviceInfo,
+  Language,
+} from "@ledgerhq/types-live";
 
 async function hasOudatedApps({
   deviceInfo,
@@ -71,3 +75,19 @@ export function useManagerBlueDot(
   }, [dmi, forceProvider]);
   return display;
 }
+
+export const useAvailableLanguagesForDevice = (
+  deviceInfo: DeviceInfo
+): Language[] => {
+  const [availableLanguages, setAvailableLanguages] = useState<Language[]>([]);
+
+  useEffect(() => {
+    if (deviceInfo) {
+      manager
+        .getAvailableLanguagesDevice(deviceInfo)
+        .then(setAvailableLanguages);
+    }
+  }, [deviceInfo, setAvailableLanguages]);
+
+  return availableLanguages;
+};

package/src/manager/index.ts

@@ -8,6 +8,7 @@ import { listCryptoCurrencies } from "../currencies";
 import ManagerAPI from "../api/Manager";
 import { getProviderId } from "./provider";
 import type {
+  Language,
   ApplicationVersion,
   DeviceInfo,
   FirmwareUpdateContext,
@@ -158,6 +159,21 @@ const CacheAPI = {
       shouldFlashMCU,
     };
   },
+  // get list of available languages for a given deviceInfo
+  getAvailableLanguagesDevice: async (
+    deviceInfo: DeviceInfo
+  ): Promise<Language[]> => {
+    const languagePackages = await ManagerAPI.getLanguagePackagesForDevice(
+      deviceInfo
+    );
+    const languages = languagePackages.map((pack) => pack.language);
+
+    if (!languages.includes("english")) {
+      languages.push("english"); // english is always available
+    }
+
+    return languages;
+  },
   // get list of apps for a given deviceInfo
   getAppsList: async (
     deviceInfo: DeviceInfo,

package/src/manager/localization.ts

@@ -0,0 +1,19 @@
+import { DeviceModelId } from "@ledgerhq/devices";
+import { satisfies as versionSatisfies } from "semver";
+
+const deviceVersionRangesForLocalization: { [key in DeviceModelId]?: string } =
+  {
+    nanoX: ">=2.1.0 || =2.1.0-lo2 || =2.1.0-lo4 || =2.1.0-lo5",
+    nanoSP: ">=1.1.0 || =1.1.0-lo1",
+  };
+
+export const isDeviceLocalizationSupported = (
+  seVersion: string,
+  modelId?: DeviceModelId
+) =>
+  modelId &&
+  deviceVersionRangesForLocalization[modelId] &&
+  versionSatisfies(
+    seVersion,
+    deviceVersionRangesForLocalization[modelId] as string
+  );

package/src/platform/react.ts

@@ -30,14 +30,18 @@ export function usePlatformUrl(
 
     if (inputs) {
       for (const key in inputs) {
-        if (Object.prototype.hasOwnProperty.call(inputs, key)) {
+        if (
+          Object.prototype.hasOwnProperty.call(inputs, key) &&
+          inputs[key] !== undefined
+        ) {
           url.searchParams.set(key, inputs[key]);
         }
       }
     }
 
-    url.searchParams.set("backgroundColor", params.background);
-    url.searchParams.set("textColor", params.text);
+    if (params.background)
+      url.searchParams.set("backgroundColor", params.background);
+    if (params.text) url.searchParams.set("textColor", params.text);
     if (params.loadDate) {
       url.searchParams.set("loadDate", params.loadDate.valueOf().toString());
     }