@ledgerhq/live-common 34.38.1-hotfix.0 → 34.38.2-nightly.0

package/src/deposit/helper.ts

@@ -1,8 +1,12 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { MappedAsset, CurrenciesByProviderId, GroupedCurrencies } from "./type";
-import { currenciesByMarketcap } from "../currencies";
+import {
+  currenciesByMarketcap,
+  getCryptoCurrencyById,
+  getTokenById,
+  hasCryptoCurrencyId,
+} from "../currencies";
 import { getMappedAssets } from "./api";
-
 export const loadCurrenciesByProvider = async (
   coinsAndTokensSupported: CryptoOrTokenCurrency[],
 ): Promise<GroupedCurrencies> => {
@@ -10,9 +14,9 @@ export const loadCurrenciesByProvider = async (
     currenciesByMarketcap(coinsAndTokensSupported),
     getMappedAssets(),
   ]);
+
   return groupCurrenciesByProvider(assets, sortedCurrenciesSupported);
 };
-
 export const groupCurrenciesByProvider = (
   assets: MappedAsset[],
   sortedCurrencies: CryptoOrTokenCurrency[],
@@ -23,7 +27,7 @@ export const groupCurrenciesByProvider = (
     assetsByLedgerId.set(asset.ledgerId.toLowerCase(), asset);
   }
   const assetsByProviderId: Map<string, CurrenciesByProviderId> = new Map();
-  const sortedCryptoCurrenciesMap: Map<string, CryptoOrTokenCurrency> = new Map();
+  const sortedCryptoCurrencies: CryptoOrTokenCurrency[] = [];
   // iterate over currencies by preserving their order
   for (const ledgerCurrency of sortedCurrencies) {
     /// FIXME(LIVE-10508) drop usage of toLowerCase
@@ -39,23 +43,37 @@ export const groupCurrenciesByProvider = (
       } else {
         existingEntry.currenciesByNetwork.push(ledgerCurrency);
       }
-      if (!sortedCryptoCurrenciesMap.has(ledgerCurrency.name)) {
-        sortedCryptoCurrenciesMap.set(ledgerCurrency.name, ledgerCurrency);
-      }
     }
   }
+
+  // in this case, the first currency of the provider is the one we want to display (Wasn't true)
+  // So we need to take the first crypto or token currency of each provider to fix that
+  for (const [, { currenciesByNetwork }] of assetsByProviderId.entries()) {
+    const firstCrypto = currenciesByNetwork.find(c => c.type === "CryptoCurrency");
+    const elem = firstCrypto ?? currenciesByNetwork.find(c => c.type === "TokenCurrency");
+    if (elem) {
+      sortedCryptoCurrencies.push(elem);
+    }
+  }
+
   return {
     currenciesByProvider: Array.from(assetsByProviderId.values()),
-    sortedCryptoCurrencies: Array.from(sortedCryptoCurrenciesMap.values()),
+    sortedCryptoCurrencies,
   };
 };
 
 export const searchByProviderId = (list: MappedAsset[], providerId: string) =>
   list.filter(elem => elem.providerId.toLowerCase() === providerId.toLowerCase());
-
 export const searchByNameOrTicker = (list: MappedAsset[], nameOrTicker: string) =>
   list.filter(
     elem =>
       elem.name.toLowerCase().includes(nameOrTicker.toLowerCase()) ||
       elem.ticker.toLowerCase().includes(nameOrTicker.toLowerCase()),
   );
+
+export const getTokenOrCryptoCurrencyById = (id: string): CryptoOrTokenCurrency => {
+  if (hasCryptoCurrencyId(id)) {
+    return getCryptoCurrencyById(id);
+  }
+  return getTokenById(id);
+};

package/src/deviceSDK/tasks/getDeviceInfo.ts

@@ -81,6 +81,7 @@ export const parseDeviceInfo = (firmwareInfo: FirmwareInfo): DeviceInfo => {
     bootloaderVersion,
     hardwareVersion,
     languageId,
+    charonState,
   } = firmwareInfo;
 
   const isOSU = rawVersion.includes("-osu");
@@ -130,6 +131,8 @@ export const parseDeviceInfo = (firmwareInfo: FirmwareInfo): DeviceInfo => {
     bootloaderVersion,
     hardwareVersion,
     languageId,
+    seFlags: flags,
+    charonState: charonState,
   };
 
   return deviceInfo;

package/src/e2e/enum/Provider.ts

@@ -9,7 +9,7 @@ export class Provider {
   static readonly CHANGELLY = new Provider("changelly", "Changelly", false, true, true);
   static readonly EXODUS = new Provider("exodus", "Exodus", false, true, true);
   static readonly ONE_INCH = new Provider("oneinch", "1inch", false, false, true);
-  static readonly PARASWAP = new Provider("paraswap", "Paraswap", false, false, true);
+  static readonly VELORA = new Provider("velora", "Velora", false, false, true);
   static readonly MOONPAY = new Provider("moonpay", "MoonPay", true, false, true);
   static readonly THORCHAIN = new Provider("thorswap", "THORChain", false, true, false);
   static readonly UNISWAP = new Provider("uniswap", "Uniswap", false, false, false);

package/src/e2e/swap.ts

@@ -3,7 +3,7 @@ import axios from "axios";
 
 export async function getMinimumSwapAmount(AccountFrom: Account, AccountTo: Account) {
   try {
-    const { data } = await axios({
+    const requestConfig = {
       method: "GET",
       url: `https://swap-stg.ledger-test.com/v5/quote`,
       params: {
@@ -24,16 +24,21 @@ export async function getMinimumSwapAmount(AccountFrom: Account, AccountTo: Acco
       headers: {
         accept: "application/json",
       },
-    });
+    };
 
-    const minimumAmounts = data.map((item: any) => {
-      return parseFloat(item.parameter.minAmount);
-    });
+    const { data } = await axios(requestConfig);
+
+    const minimumAmounts = data
+      .filter((item: any) => item.parameter?.minAmount !== undefined)
+      .map((item: any) => parseFloat(item.parameter.minAmount));
 
     const validMinimumAmounts = minimumAmounts.filter((amount: number) => !isNaN(amount));
 
-    const maxMinAmount = Math.max(...validMinimumAmounts);
-    return maxMinAmount;
+    if (validMinimumAmounts.length === 0) {
+      throw new Error("No valid minimum amounts returned from swap quote API.");
+    }
+
+    return Math.max(...validMinimumAmounts);
   } catch (error) {
     console.error(error);
   }

package/src/featureFlags/defaultFeatures.ts

@@ -619,6 +619,17 @@ export const DEFAULT_FEATURES: Features = {
       enableModularization: false,
     },
   },
+  llmModularDrawer: {
+    ...DEFAULT_FEATURE,
+    params: {
+      add_account: true,
+      earn_flow: true,
+      live_app: true,
+      receive_flow: true,
+      send_flow: true,
+      enableModularization: false,
+    },
+  },
   llNftSupport: DEFAULT_FEATURE,
   llNftEntryPoint: {
     ...DEFAULT_FEATURE,
@@ -632,6 +643,30 @@ export const DEFAULT_FEATURES: Features = {
   lldNetworkBasedAddAccount: DEFAULT_FEATURE,
   llmOfacGeoBlocking: DEFAULT_FEATURE,
   lldOfacGeoBlocking: DEFAULT_FEATURE,
+  llmDatadog: {
+    ...DEFAULT_FEATURE,
+    params: {
+      batchProcessingLevel: "MEDIUM",
+      batchSize: "MEDIUM",
+      bundleLogsWithRum: true,
+      bundleLogsWithTraces: true,
+      longTaskThresholdMs: 0,
+      nativeInteractionTracking: false,
+      nativeLongTaskThresholdMs: 0,
+      nativeViewTracking: false,
+      resourceTracingSamplingRate: 0,
+      serviceName: "Ledger Live Mobile (default)",
+      sessionSamplingRate: 0,
+      trackBackgroundEvents: false,
+      trackFrustrations: true,
+      trackErrors: false,
+      trackResources: false,
+      trackInteractions: false,
+      trackWatchdogTerminations: false,
+      uploadFrequency: "AVERAGE",
+      vitalsUpdateFrequency: "AVERAGE",
+    },
+  },
 };
 
 // Firebase SDK treat JSON values as strings

package/src/hooks/useAppVersionBlockCheck.test.ts

@@ -0,0 +1,134 @@
+import { useAppVersionBlockCheck } from "./useAppVersionBlockCheck";
+
+describe("useAppVersionBlockCheck", () => {
+  describe("LLM", () => {
+    it("should update if current version is not compatible on android", () => {
+      // given
+      const getConfigValue = () => ({
+        llm: {
+          android: [
+            {
+              minOsVersion: "32",
+              version: "2.0.3",
+            },
+          ],
+        },
+      });
+      // when
+      const { shouldUpdate } = useAppVersionBlockCheck({
+        appVersion: "2.0.1",
+        osVersion: "32",
+        platform: "android",
+        appKey: "llm",
+        getConfigValue,
+      });
+      //then
+      expect(shouldUpdate).toBe(true);
+    });
+    it("should update if current version is not compatible on ios", () => {
+      const getConfigValue = () => ({
+        llm: {
+          ios: [
+            {
+              minOsVersion: "32",
+              version: "2.0.3",
+            },
+          ],
+        },
+      });
+      // when
+      const { shouldUpdate } = useAppVersionBlockCheck({
+        appVersion: "2.0.1",
+        osVersion: "32",
+        platform: "ios",
+        appKey: "llm",
+        getConfigValue,
+      });
+      //then
+      expect(shouldUpdate).toBe(true);
+    });
+    it("should not update the app if current version is not compatible on android with another os version", () => {
+      // given
+      const getConfigValue = () => ({
+        llm: {
+          android: [
+            {
+              minOsVersion: "33",
+              version: "2.0.3",
+            },
+          ],
+        },
+      });
+      // when
+      const { shouldUpdate } = useAppVersionBlockCheck({
+        appVersion: "2.0.1",
+        osVersion: "32",
+        platform: "android",
+        appKey: "llm",
+        getConfigValue,
+      });
+      //then
+      expect(shouldUpdate).toBe(false);
+    });
+    it("should not update the app if current version is not compatible on ios with another os version", () => {
+      // given
+      const getConfigValue = () => ({
+        llm: {
+          ios: [
+            {
+              minOsVersion: "33",
+              version: "2.0.3",
+            },
+          ],
+        },
+      });
+      // when
+      const { shouldUpdate } = useAppVersionBlockCheck({
+        appVersion: "2.0.1",
+        osVersion: "32",
+        platform: "ios",
+        appKey: "llm",
+        getConfigValue,
+      });
+      //then
+      expect(shouldUpdate).toBe(false);
+    });
+    it.each([
+      ["android", "2.1.3"],
+      ["ios", "2.1.3"],
+      ["android", "2.1.3-rc.2"],
+      ["ios", "2.1.3-rc.2"],
+      ["android", "2.2.3-next.0"],
+      ["ios", "2.2.3-next.0"],
+      ["android", "2.0.3-rc2"],
+      ["ios", "2.0.3-rc2"],
+      ["android", "2.0.3-next.3"],
+      ["ios", "2.0.3-next.3"],
+    ])(
+      "should not update the app on %s for version %s compatible with 2.0.3",
+      (platform, appVersion) => {
+        // given
+        const getConfigValue = () => ({
+          llm: {
+            [platform]: [
+              {
+                minOsVersion: "32",
+                version: "2.0.3",
+              },
+            ],
+          },
+        });
+        // when
+        const { shouldUpdate } = useAppVersionBlockCheck({
+          appVersion,
+          osVersion: "32",
+          platform: platform as "ios" | "android",
+          appKey: "llm",
+          getConfigValue,
+        });
+        // then
+        expect(shouldUpdate).toBe(false);
+      },
+    );
+  });
+});

package/src/hooks/useAppVersionBlockCheck.ts

@@ -0,0 +1,65 @@
+import semver from "semver";
+import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
+
+type LLMMinVersionConfig = {
+  minOsVersion: string;
+  version: string;
+};
+
+type LLMinVersionConfig = {
+  lld: {
+    windows: string;
+    macOS: string;
+    linux: string;
+  };
+  llm: {
+    android: LLMMinVersionConfig[];
+    ios: LLMMinVersionConfig[];
+  };
+};
+
+const checkLLmVersion = (
+  appVersion: string,
+  osVersion: string,
+  platform: "ios" | "android",
+  llmMinVersionConfig: LLMinVersionConfig["llm"],
+) => {
+  if (!llmMinVersionConfig[platform]) {
+    return false;
+  }
+
+  return llmMinVersionConfig[platform]
+    .filter(minVersionConfig =>
+      semver.satisfies(semver.coerce(osVersion), `>=${minVersionConfig.minOsVersion}`),
+    )
+    .reduce((acc, curr) => {
+      return acc || semver.satisfies(appVersion, `<${curr.version}`);
+    }, false);
+};
+
+export const useAppVersionBlockCheck = ({
+  appVersion: uncoercedAppVersion,
+  appKey,
+  platform,
+  osVersion,
+  getConfigValue = LiveConfig.getValueByKey,
+}: {
+  appVersion: string;
+  osVersion?: string;
+  appKey: "llm" | "lld";
+  platform: "ios" | "android" | "macOS" | "windows" | "linux";
+  getConfigValue?: typeof LiveConfig.getValueByKey;
+}) => {
+  const llMinVersionConfig = getConfigValue("config_ll_min_version");
+  const appVersion = semver.coerce(uncoercedAppVersion)?.version || "";
+  let shouldUpdate = false;
+
+  if (!llMinVersionConfig) {
+    return { shouldUpdate };
+  }
+
+  if (appKey === "llm" && (platform === "android" || platform === "ios") && osVersion) {
+    shouldUpdate = checkLLmVersion(appVersion, osVersion, platform, llMinVersionConfig[appKey]);
+  }
+  return { shouldUpdate };
+};

package/src/hw/connectAppEventMapper.ts

@@ -203,7 +203,9 @@ export class ConnectAppEventMapper {
         type: "install",
         name: installPlan.installPlan[installPlan.currentIndex]!.versionName,
       },
-      installQueue: installPlan.installPlan.map(app => app.versionName),
+      installQueue: installPlan.installPlan
+        .map(app => app.versionName)
+        .slice(installPlan.currentIndex),
     });
     this.installPlan = installPlan;
   }

package/src/hw/connectManager.ts

@@ -6,6 +6,8 @@ import {
   StatusCodes,
   LockedDeviceError,
 } from "@ledgerhq/errors";
+import { isCharonSupported } from "@ledgerhq/device-core";
+import { identifyTargetId } from "@ledgerhq/devices";
 import { DeviceInfo } from "@ledgerhq/types-live";
 import type Transport from "@ledgerhq/hw-transport";
 import type { DeviceManagementKit } from "@ledgerhq/device-management-kit";
@@ -21,6 +23,7 @@ import attemptToQuitApp, { AttemptToQuitAppEvent } from "./attemptToQuitApp";
 import { LockedDeviceEvent } from "./actions/types";
 import { ManagerRequest } from "./actions/manager";
 import { PrepareConnectManagerEventMapper } from "./connectManagerEventMapper";
+import { extractOnboardingState, OnboardingStep } from "./extractOnboardingState";
 
 export type Input = {
   deviceId: string;
@@ -61,6 +64,21 @@ const cmd = (transport: Transport, { request }: Input): Observable<ConnectManage
             throw new DeviceNotOnboarded();
           }
 
+          if (
+            isCharonSupported(
+              deviceInfo.seVersion ?? "",
+              identifyTargetId(deviceInfo.seTargetId ?? 0)?.id,
+            )
+          ) {
+            const onboardingState = extractOnboardingState(
+              deviceInfo.seFlags,
+              deviceInfo.charonState,
+            );
+            if (onboardingState.currentOnboardingStep === OnboardingStep.BackupCharon) {
+              throw new DeviceNotOnboarded();
+            }
+          }
+
           if (deviceInfo.isBootloader) {
             return of({
               type: "bootloader",

package/src/hw/customLockScreenLoad.test.ts

@@ -0,0 +1,86 @@
+import customLockScreenLoad from "./customLockScreenLoad";
+import { DeviceModelId } from "@ledgerhq/devices";
+import { CLSSupportedDeviceModelId } from "@ledgerhq/device-core";
+import { lastValueFrom, of } from "rxjs";
+import { ManagerNotEnoughSpaceError, StatusCodes, TransportError } from "@ledgerhq/errors";
+import { ImageLoadRefusedOnDevice } from "../errors";
+
+const mockTransport = {
+  send: jest.fn(),
+  getTraceContext: jest.fn(),
+};
+jest.mock("../deviceSDK/transports/core", () => ({
+  withTransport: () => callback => callback({ transportRef: { current: mockTransport } }),
+}));
+jest.mock("./getDeviceInfo", () => jest.fn(() => of([])));
+
+describe("customLockScreenLoad", () => {
+  it("should load image on device", async () => {
+    // given
+    const request = {
+      deviceModelId: DeviceModelId.stax as CLSSupportedDeviceModelId,
+      hexImage: "hello_world",
+    };
+    mockTransport.send.mockResolvedValue(Buffer.from([0x42, 0x42, 0x43, 0x90, 0x00]));
+
+    // when
+    const ret = await lastValueFrom(await customLockScreenLoad({ deviceId: "deviceId", request }));
+
+    // then
+    expect(mockTransport.send).toHaveBeenNthCalledWith(
+      1,
+      0xe0,
+      0x60,
+      0x00,
+      0x00,
+      Buffer.from([0x00, 0x00, 0x00, 0x08]),
+      [StatusCodes.NOT_ENOUGH_SPACE, StatusCodes.USER_REFUSED_ON_DEVICE, StatusCodes.OK],
+    );
+    expect(mockTransport.send).toHaveBeenNthCalledWith(
+      2,
+      0xe0,
+      0x61,
+      0x00,
+      0x00,
+      Buffer.from([0x00, 0x00, 0x00, 0x00, 0x90, 0x01, 0xa0, 0x02, 0x21, 0x00, 0x00, 0x00]),
+    );
+    expect(mockTransport.send).toHaveBeenNthCalledWith(
+      3,
+      0xe0,
+      0x62,
+      0x00,
+      0x00,
+      Buffer.from([]),
+      [0x9000, 0x5501],
+    );
+    expect(ret).toStrictEqual({
+      type: "imageLoaded",
+      imageSize: 1111638928,
+      imageHash: "424243",
+    });
+  });
+
+  it.each([
+    [
+      "user refused on device",
+      [0x55, 0x01],
+      new ImageLoadRefusedOnDevice("5501", { productName: "Ledger Stax" }),
+    ],
+    ["not enough space", [0x51, 0x02], new ManagerNotEnoughSpaceError()],
+    ["unexpected error", [0x42, 0x32], new TransportError("Unexpected device response", "4232")],
+  ])("should return an error if %s", async (_errorStr, statusCode, error) => {
+    // given
+    const request = {
+      deviceModelId: DeviceModelId.stax as CLSSupportedDeviceModelId,
+      hexImage: "hello_world",
+    };
+    mockTransport.send.mockResolvedValue(Buffer.from(statusCode));
+
+    // when
+    try {
+      await lastValueFrom(await customLockScreenLoad({ deviceId: "nanoX", request }));
+    } catch (err) {
+      expect(err).toStrictEqual(error);
+    }
+  });
+});

package/src/hw/customLockScreenLoad.ts

@@ -10,7 +10,6 @@ import {
 } from "@ledgerhq/errors";
 import { getDeviceModel } from "@ledgerhq/devices";
 
-import { withDevice } from "./deviceAccess";
 import getDeviceInfo from "./getDeviceInfo";
 import { ImageLoadRefusedOnDevice, ImageCommitRefusedOnDevice } from "../errors";
 import getAppAndVersion from "./getAppAndVersion";
@@ -21,6 +20,8 @@ import customLockScreenFetchHash from "./customLockScreenFetchHash";
 import { gzip } from "pako";
 import { CLSSupportedDeviceModelId } from "../device/use-cases/isCustomLockScreenSupported";
 import { getScreenSpecs } from "../device/use-cases/screenSpecs";
+import { DeviceDisconnectedWhileSendingError } from "@ledgerhq/device-management-kit";
+import { withTransport } from "../deviceSDK/transports/core";
 
 const MAX_APDU_SIZE = 255;
 const COMPRESS_CHUNK_SIZE = 2048;
@@ -43,6 +44,17 @@ export type LoadImageEvent =
       imageHash: string;
     };
 
+/**
+ * Type guard to check if the given error is a DeviceDisconnectedWhileSendingError.
+ * Ensures that the error is an object, is not null, and matches the expected structure.
+ * This is used to identify specific disconnection errors from the DMK device.
+ */
+const isDmkDeviceDisconnectedError = (err: unknown): err is DeviceDisconnectedWhileSendingError =>
+  typeof err === "object" &&
+  err !== null &&
+  (err instanceof DeviceDisconnectedWhileSendingError ||
+    ("_tag" in err && err._tag === "DeviceDisconnectedWhileSendingError"));
+
 export type LoadimageResult = {
   imageHash: string;
   imageSize: number;
@@ -72,14 +84,14 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
   const { hexImage, padImage = true, deviceModelId } = request;
   const screenSpecs = getScreenSpecs(deviceModelId);
 
-  const sub = withDevice(deviceId)(
-    transport =>
+  const sub = withTransport(deviceId)(
+    ({ transportRef }) =>
       new Observable(subscriber => {
         const timeoutSub = of<LoadImageEvent>({ type: "unresponsiveDevice" })
           .pipe(delay(1000))
           .subscribe(e => subscriber.next(e));
 
-        const sub = from(getDeviceInfo(transport))
+        const sub = from(getDeviceInfo(transportRef.current))
           .pipe(
             mergeMap(async () => {
               timeoutSub.unsubscribe();
@@ -96,11 +108,14 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
               imageSize.writeUIntBE(imageLength, 0, 4);
 
               subscriber.next({ type: "loadImagePermissionRequested" });
-              const createImageResponse = await transport.send(0xe0, 0x60, 0x00, 0x00, imageSize, [
-                StatusCodes.NOT_ENOUGH_SPACE,
-                StatusCodes.USER_REFUSED_ON_DEVICE,
-                StatusCodes.OK,
-              ]);
+              const createImageResponse = await transportRef.current.send(
+                0xe0,
+                0x60,
+                0x00,
+                0x00,
+                imageSize,
+                [StatusCodes.NOT_ENOUGH_SPACE, StatusCodes.USER_REFUSED_ON_DEVICE, StatusCodes.OK],
+              );
 
               const createImageStatus = createImageResponse.readUInt16BE(
                 createImageResponse.length - 2,
@@ -140,13 +155,13 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
                 chunkOffsetBuffer.writeUIntBE(currentOffset, 0, 4);
 
                 const apduData = Buffer.concat([chunkOffsetBuffer, chunkDataBuffer]);
-                await transport.send(0xe0, 0x61, 0x00, 0x00, apduData);
+                await transportRef.current.send(0xe0, 0x61, 0x00, 0x00, apduData);
                 currentOffset += chunkSize;
               }
 
               subscriber.next({ type: "commitImagePermissionRequested" });
 
-              const commitResponse = await transport.send(
+              const commitResponse = await transportRef.current.send(
                 0xe0,
                 0x62,
                 0x00,
@@ -172,10 +187,10 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
               }
 
               // Fetch image size
-              const imageBytes = await customLockScreenFetchSize(transport);
+              const imageBytes = await customLockScreenFetchSize(transportRef.current);
 
               // Fetch image hash
-              const imageHash = await customLockScreenFetchHash(transport);
+              const imageHash = await customLockScreenFetchHash(transportRef.current);
 
               subscriber.next({
                 type: "imageLoaded",
@@ -192,10 +207,10 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
                   e instanceof TransportStatusError &&
                   [0x6e00, 0x6d00, 0x6e01, 0x6d01, 0x6d02].includes(e.statusCode))
               ) {
-                return from(getAppAndVersion(transport)).pipe(
+                return from(getAppAndVersion(transportRef.current)).pipe(
                   concatMap(appAndVersion => {
                     return !isDashboardName(appAndVersion.name)
-                      ? attemptToQuitApp(transport, appAndVersion)
+                      ? attemptToQuitApp(transportRef.current, appAndVersion)
                       : of<LoadImageEvent>({
                           type: "appDetected",
                         });
@@ -213,9 +228,8 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
         };
       }),
   ).pipe(
-    // timeout(5000),
     catchError(err => {
-      if (err.name === "TimeoutError") {
+      if (err.name === "TimeoutError" || isDmkDeviceDisconnectedError(err)) {
         return throwError(() => new DisconnectedDevice());
       }
       return throwError(() => err);