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

package/src/generated/specs.ts

@@ -1,38 +1,21 @@
 import algorand from "../families/algorand/specs";
-
 import bitcoin from "../families/bitcoin/specs";
-
 import cardano from "../families/cardano/specs";
-
 import celo from "../families/celo/specs";
-
 import cosmos from "../families/cosmos/specs";
-
 import crypto_org from "../families/crypto_org/specs";
-
 import elrond from "../families/elrond/specs";
-
 import ethereum from "../families/ethereum/specs";
-
 import filecoin from "../families/filecoin/specs";
-
 import hedera from "../families/hedera/specs";
-
 import osmosis from "../families/osmosis/specs";
-
 import polkadot from "../families/polkadot/specs";
-
 import ripple from "../families/ripple/specs";
-
 import solana from "../families/solana/specs";
-
 import stellar from "../families/stellar/specs";
-
 import tezos from "../families/tezos/specs";
-
 import tron from "../families/tron/specs";
 
-
 export default {
   algorand,
   bitcoin,

package/src/generated/speculos-deviceActions.ts

@@ -1,38 +1,21 @@
 import algorand from "../families/algorand/speculos-deviceActions";
-
 import bitcoin from "../families/bitcoin/speculos-deviceActions";
-
 import cardano from "../families/cardano/speculos-deviceActions";
-
 import celo from "../families/celo/speculos-deviceActions";
-
 import cosmos from "../families/cosmos/speculos-deviceActions";
-
 import crypto_org from "../families/crypto_org/speculos-deviceActions";
-
 import elrond from "../families/elrond/speculos-deviceActions";
-
 import ethereum from "../families/ethereum/speculos-deviceActions";
-
 import filecoin from "../families/filecoin/speculos-deviceActions";
-
 import hedera from "../families/hedera/speculos-deviceActions";
-
 import osmosis from "../families/osmosis/speculos-deviceActions";
-
 import polkadot from "../families/polkadot/speculos-deviceActions";
-
 import ripple from "../families/ripple/speculos-deviceActions";
-
 import solana from "../families/solana/speculos-deviceActions";
-
 import stellar from "../families/stellar/speculos-deviceActions";
-
 import tezos from "../families/tezos/speculos-deviceActions";
-
 import tron from "../families/tron/speculos-deviceActions";
 
-
 export default {
   algorand,
   bitcoin,

package/src/generated/transaction.ts

@@ -1,40 +1,22 @@
 import algorand from "../families/algorand/transaction";
-
 import bitcoin from "../families/bitcoin/transaction";
-
 import cardano from "../families/cardano/transaction";
-
 import celo from "../families/celo/transaction";
-
 import cosmos from "../families/cosmos/transaction";
-
 import crypto_org from "../families/crypto_org/transaction";
-
 import elrond from "../families/elrond/transaction";
-
 import ethereum from "../families/ethereum/transaction";
-
 import filecoin from "../families/filecoin/transaction";
-
 import hedera from "../families/hedera/transaction";
-
 import neo from "../families/neo/transaction";
-
 import osmosis from "../families/osmosis/transaction";
-
 import polkadot from "../families/polkadot/transaction";
-
 import ripple from "../families/ripple/transaction";
-
 import solana from "../families/solana/transaction";
-
 import stellar from "../families/stellar/transaction";
-
 import tezos from "../families/tezos/transaction";
-
 import tron from "../families/tron/transaction";
 
-
 export default {
   algorand,
   bitcoin,

package/src/generated/types.ts

@@ -89,7 +89,8 @@ export type Transaction =
   | solanaTransaction
   | stellarTransaction
   | tezosTransaction
-  | tronTransaction
+  | tronTransaction;
+
 export type TransactionRaw =
   | algorandTransactionRaw
   | bitcoinTransactionRaw
@@ -108,7 +109,8 @@ export type TransactionRaw =
   | solanaTransactionRaw
   | stellarTransactionRaw
   | tezosTransactionRaw
-  | tronTransactionRaw
+  | tronTransactionRaw;
+
 export type TransactionStatus =
   | algorandTransactionStatus
   | bitcoinTransactionStatus
@@ -127,7 +129,8 @@ export type TransactionStatus =
   | solanaTransactionStatus
   | stellarTransactionStatus
   | tezosTransactionStatus
-  | tronTransactionStatus
+  | tronTransactionStatus;
+
 export type TransactionStatusRaw =
   | algorandTransactionStatusRaw
   | bitcoinTransactionStatusRaw
@@ -146,4 +149,4 @@ export type TransactionStatusRaw =
   | solanaTransactionStatusRaw
   | stellarTransactionStatusRaw
   | tezosTransactionStatusRaw
-  | tronTransactionStatusRaw
+  | tronTransactionStatusRaw;

package/src/hw/actions/installLanguage.ts

@@ -0,0 +1,343 @@
+import {
+  concat,
+  of,
+  EMPTY,
+  interval,
+  Observable,
+  TimeoutError,
+  throwError,
+} from "rxjs";
+import {
+  scan,
+  debounce,
+  debounceTime,
+  catchError,
+  switchMap,
+  tap,
+  distinctUntilChanged,
+  timeout,
+} from "rxjs/operators";
+import { useEffect, useState } from "react";
+import { log } from "@ledgerhq/logs";
+import type { DeviceInfo } from "@ledgerhq/types-live";
+import { useReplaySubject } from "../../observable";
+import type {
+  InstallLanguageEvent,
+  InstallLanguageRequest,
+} from "../installLanguage";
+import type { Action, Device } from "./types";
+import isEqual from "lodash/isEqual";
+import { ConnectManagerTimeout } from "../../errors";
+import { currentMode } from "./app";
+import {
+  DisconnectedDevice,
+  DisconnectedDeviceDuringOperation,
+} from "@ledgerhq/errors";
+import { getDeviceModel } from "@ledgerhq/devices";
+import { Language } from "@ledgerhq/types-live";
+
+type State = {
+  isLoading: boolean;
+  requestQuitApp: boolean;
+  unresponsive: boolean;
+  languageInstallationRequested?: boolean;
+  installingLanguage?: boolean;
+  languageInstalled?: boolean;
+  device: Device | null | undefined;
+  deviceInfo: DeviceInfo | null | undefined;
+  error: Error | null | undefined;
+  progress?: number;
+};
+
+type InstallLanguageAction = Action<Language, State, boolean | undefined>;
+
+const mapResult = ({ languageInstalled }: State) => languageInstalled;
+
+type Event =
+  | InstallLanguageEvent
+  | {
+      type: "error";
+      error: Error;
+    }
+  | {
+      type: "deviceChange";
+      device: Device | null | undefined;
+    };
+
+const getInitialState = (device?: Device | null | undefined): State => ({
+  isLoading: !!device,
+  requestQuitApp: false,
+  unresponsive: false,
+  device,
+  deviceInfo: null,
+  error: null,
+});
+
+const reducer = (state: State, e: Event): State => {
+  switch (e.type) {
+    case "unresponsiveDevice":
+      return { ...state, unresponsive: true, isLoading: false };
+
+    case "deviceChange":
+      return getInitialState(e.device);
+
+    case "error":
+      return {
+        ...getInitialState(state.device),
+        error: e.error,
+        isLoading: false,
+      };
+    case "appDetected":
+      return {
+        ...state,
+        unresponsive: false,
+        requestQuitApp: true,
+        isLoading: false,
+      };
+    case "devicePermissionRequested":
+      return {
+        ...state,
+        unresponsive: false,
+        languageInstallationRequested: true,
+        isLoading: false,
+      };
+    case "languageInstalled":
+      return {
+        ...state,
+        unresponsive: false,
+        languageInstallationRequested: false,
+        isLoading: false,
+        installingLanguage: false,
+        languageInstalled: true,
+      };
+
+    case "progress":
+      return {
+        ...state,
+        unresponsive: false,
+        languageInstallationRequested: false,
+        isLoading: false,
+        installingLanguage: true,
+        progress: e.progress,
+      };
+  }
+};
+
+const implementations = {
+  // in this paradigm, we know that deviceSubject is reflecting the device events
+  // so we just trust deviceSubject to reflect the device context (switch between apps, dashboard,...)
+  event: ({ deviceSubject, installLanguage, language }) =>
+    deviceSubject.pipe(
+      debounceTime(1000),
+      switchMap((d) => installLanguage(d, language))
+    ),
+  // in this paradigm, we can't observe directly the device, so we have to poll it
+  polling: ({ deviceSubject, installLanguage, language }) =>
+    new Observable((o) => {
+      const POLLING = 2000;
+      const INIT_DEBOUNCE = 5000;
+      const DISCONNECT_DEBOUNCE = 5000;
+      const DEVICE_POLLING_TIMEOUT = 20000;
+      // this pattern allows to actually support events based (like if deviceSubject emits new device changes) but inside polling paradigm
+      let pollingOnDevice;
+      const sub = deviceSubject.subscribe((d) => {
+        if (d) {
+          pollingOnDevice = d;
+        }
+      });
+      let initT: NodeJS.Timeout | null = setTimeout(() => {
+        // initial timeout to unset the device if it's still not connected
+        o.next({
+          type: "deviceChange",
+          device: null,
+        });
+        device = null;
+        log("actions-install-language-event/polling", "device init timeout");
+      }, INIT_DEBOUNCE);
+      let connectSub;
+      let loopT;
+      let disconnectT;
+      let device = null; // used as internal state for polling
+
+      let stopDevicePollingError = null;
+
+      function loop() {
+        stopDevicePollingError = null;
+
+        if (!pollingOnDevice) {
+          loopT = setTimeout(loop, POLLING);
+          return;
+        }
+
+        log("actions-install-language-event/polling", "polling loop");
+        connectSub = installLanguage(pollingOnDevice, language)
+          .pipe(
+            timeout(DEVICE_POLLING_TIMEOUT),
+            catchError((err) => {
+              const productName = getDeviceModel(
+                pollingOnDevice.modelId
+              ).productName;
+              return err instanceof TimeoutError
+                ? of({
+                    type: "error",
+                    error: new ConnectManagerTimeout(undefined, {
+                      productName,
+                    }) as Error,
+                  })
+                : throwError(err);
+            })
+          )
+          .subscribe({
+            next: (event) => {
+              if (initT && device) {
+                clearTimeout(initT);
+                initT = null;
+              }
+
+              if (disconnectT) {
+                // any connect app event unschedule the disconnect debounced event
+                clearTimeout(disconnectT);
+                disconnectT = null;
+              }
+
+              if (event.type === "error" && event.error) {
+                if (
+                  event.error instanceof DisconnectedDevice ||
+                  event.error instanceof DisconnectedDeviceDuringOperation
+                ) {
+                  // disconnect on manager actions seems to trigger a type "error" instead of "disconnect"
+                  // the disconnect event is delayed to debounce the reconnection that happens when switching apps
+                  disconnectT = setTimeout(() => {
+                    disconnectT = null;
+                    // a disconnect will locally be remembered via locally setting device to null...
+                    device = null;
+                    o.next(event);
+                    log(
+                      "actions-install-language-event/polling",
+                      "device disconnect timeout"
+                    );
+                  }, DISCONNECT_DEBOUNCE);
+                } else {
+                  // These error events should stop polling
+                  stopDevicePollingError = event.error;
+
+                  // clear all potential polling loops
+                  if (loopT) {
+                    clearTimeout(loopT);
+                    loopT = null;
+                  }
+
+                  // send in the event for the UI immediately
+                  o.next(event);
+                }
+              } else if (event.type === "unresponsiveDevice") {
+                return; // ignore unresponsive case which happens for polling
+              } else {
+                if (device !== pollingOnDevice) {
+                  // ...but any time an event comes back, it means our device was responding and need to be set back on in polling context
+                  device = pollingOnDevice;
+                  o.next({
+                    type: "deviceChange",
+                    device,
+                  });
+                }
+
+                o.next(event);
+              }
+            },
+            complete: () => {
+              // start a new polling if available
+              if (!stopDevicePollingError) loopT = setTimeout(loop, POLLING);
+            },
+            error: (e) => {
+              o.error(e);
+            },
+          });
+      }
+
+      // delay a bit the first loop run in order to be async and wait pollingOnDevice
+      loopT = setTimeout(loop, 0);
+      return () => {
+        if (initT) clearTimeout(initT);
+        if (disconnectT) clearTimeout(disconnectT);
+        if (connectSub) connectSub.unsubscribe();
+        sub.unsubscribe();
+        clearTimeout(loopT);
+      };
+    }).pipe(distinctUntilChanged(isEqual)),
+};
+export const createAction = (
+  installLanuageExec: (
+    arg0: InstallLanguageRequest
+  ) => Observable<InstallLanguageEvent>
+): InstallLanguageAction => {
+  const installLanguage = (device, language: Language) => {
+    return concat(
+      of({
+        type: "deviceChange",
+        device,
+      }),
+      !device
+        ? EMPTY
+        : installLanuageExec({
+            deviceId: device.deviceId,
+            language: language,
+          }).pipe(
+            catchError((error: Error) =>
+              of({
+                type: "error",
+                error,
+              })
+            )
+          )
+    );
+  };
+
+  const useHook = (
+    device: Device | null | undefined,
+    language: Language
+  ): State => {
+    const [state, setState] = useState(() => getInitialState(device));
+    const deviceSubject = useReplaySubject(device);
+
+    useEffect(() => {
+      if (state.languageInstalled) return;
+
+      const impl = implementations[currentMode]({
+        deviceSubject,
+        installLanguage,
+        language,
+      });
+
+      const sub = impl
+        .pipe(
+          // debounce a bit the connect/disconnect event that we don't need
+          tap((e: Event) => log("actions-install-language-event", e.type, e)),
+          // we gather all events with a reducer into the UI state
+          scan(reducer, getInitialState()),
+          // we debounce the UI state to not blink on the UI
+          debounce((s: State) => {
+            if (s.installingLanguage || s.languageInstallationRequested) {
+              return EMPTY;
+            }
+
+            // default debounce (to be tweak)
+            return interval(1500);
+          })
+        ) // the state simply goes into a React state
+        .subscribe(setState);
+      return () => {
+        sub.unsubscribe();
+      };
+    }, [deviceSubject, language, state.languageInstalled]);
+
+    return {
+      ...state,
+    };
+  };
+
+  return {
+    useHook,
+    mapResult,
+  };
+};

package/src/hw/attemptToQuitApp.ts

@@ -0,0 +1,32 @@
+import { from, Observable, of, throwError } from "rxjs";
+import { catchError, concatMap } from "rxjs/operators";
+import appSupportsQuitApp from "../appSupportsQuitApp";
+import type { AppAndVersion } from "./connectApp";
+import quitApp from "./quitApp";
+
+export type AttemptToQuitAppEvent =
+  | {
+      type: "unresponsiveDevice";
+    }
+  | {
+      type: "appDetected";
+    };
+
+const attemptToQuitApp = (
+  transport,
+  appAndVersion?: AppAndVersion
+): Observable<AttemptToQuitAppEvent> =>
+  appAndVersion && appSupportsQuitApp(appAndVersion)
+    ? from(quitApp(transport)).pipe(
+        concatMap(() =>
+          of(<AttemptToQuitAppEvent>{
+            type: "unresponsiveDevice",
+          })
+        ),
+        catchError((e) => throwError(e))
+      )
+    : of({
+        type: "appDetected",
+      });
+
+export default attemptToQuitApp;

package/src/hw/connectManager.ts

@@ -9,12 +9,12 @@ import { listApps } from "../apps/hw";
 import { withDevice } from "./deviceAccess";
 import getDeviceInfo from "./getDeviceInfo";
 import getAppAndVersion from "./getAppAndVersion";
-import appSupportsQuitApp from "../appSupportsQuitApp";
 import { isDashboardName } from "./isDashboardName";
 import { DeviceNotOnboarded } from "../errors";
-import type { AppAndVersion } from "./connectApp";
-import quitApp from "./quitApp";
+
 import { DeviceInfo } from "@ledgerhq/types-live";
+import attemptToQuitApp, { AttemptToQuitAppEvent } from "./attemptToQuitApp";
+
 export type Input = {
   devicePath: string;
   managerRequest:
@@ -24,13 +24,9 @@ export type Input = {
     | null
     | undefined;
 };
+
 export type ConnectManagerEvent =
-  | {
-      type: "appDetected";
-    }
-  | {
-      type: "unresponsiveDevice";
-    }
+  | AttemptToQuitAppEvent
   | {
       type: "osu";
       deviceInfo: DeviceInfo;
@@ -45,23 +41,6 @@ export type ConnectManagerEvent =
     }
   | ListAppsEvent;
 
-const attemptToQuitApp = (
-  transport,
-  appAndVersion?: AppAndVersion
-): Observable<ConnectManagerEvent> =>
-  appAndVersion && appSupportsQuitApp(appAndVersion)
-    ? from(quitApp(transport)).pipe(
-        concatMap(() =>
-          of(<ConnectManagerEvent>{
-            type: "unresponsiveDevice",
-          })
-        ),
-        catchError((e) => throwError(e))
-      )
-    : of({
-        type: "appDetected",
-      });
-
 const cmd = ({
   devicePath,
   managerRequest,

package/src/hw/getDeviceInfo.ts

@@ -59,6 +59,9 @@ export default async function getDeviceInfo(
     mcuVersion,
     mcuTargetId,
     flags,
+    bootloaderVersion,
+    hardwareVersion,
+    languageId,
   } = res;
   const isOSU = rawVersion.includes("-osu");
   const version = rawVersion.replace("-osu", "");
@@ -105,5 +108,8 @@ export default async function getDeviceInfo(
     managerAllowed,
     pinValidated,
     onboarded,
+    bootloaderVersion,
+    hardwareVersion,
+    languageId,
   };
 }