@ledgerhq/live-common 27.1.0 → 27.2.0-next.0

package/src/families/cosmos/specs.ts

@@ -26,7 +26,7 @@ import {
 import { DeviceModelId } from "@ledgerhq/devices";
 import { acceptTransaction } from "./speculos-deviceActions";
 
-const minAmount = new BigNumber(20000);
+const minAmount = new BigNumber(10000);
 const maxAccounts = 32;
 
 // amounts of delegation are not exact so we are applying an approximation
@@ -158,13 +158,13 @@ const cosmos: AppSpec<Transaction> = {
           "already enough delegations"
         );
         const data = getCurrentCosmosPreloadData();
-        const count = 1 + Math.floor(2 * Math.random());
+        const count = 1 + Math.round(2 * Math.random() * Math.random());
         let remaining = getMaxDelegationAvailable(
           account as CosmosAccount,
           count
         )
           .minus(minAmount.times(2))
-          .times(0.25 * Math.random());
+          .times(0.1 * Math.random());
         invariant(remaining.gt(0), "not enough funds in account for delegate");
         const all = data.validators.filter(
           (v) =>
@@ -222,7 +222,7 @@ const cosmos: AppSpec<Transaction> = {
     },
     {
       name: "undelegate",
-      maxRun: 3,
+      maxRun: 5,
       transaction: ({ account, bridge }) => {
         invariant(canUndelegate(account as CosmosAccount), "can undelegate");
         const { cosmosResources } = account as CosmosAccount;
@@ -246,8 +246,8 @@ const cosmos: AppSpec<Transaction> = {
         );
         invariant(undelegateCandidate, "already pending");
 
-        const amount = (undelegateCandidate as CosmosDelegation).amount // most of the time, undelegate all
-          .times(Math.random() > 0.3 ? 1 : Math.random())
+        const amount = (undelegateCandidate as CosmosDelegation).amount
+          .times(Math.random() > 0.2 ? 1 : Math.random()) // most of the time, undelegate all
           .integerValue();
         invariant(amount.gt(0), "random amount to be positive");
 
@@ -406,10 +406,14 @@ const cosmos: AppSpec<Transaction> = {
           const d = (cosmosResources as CosmosResources).delegations.find(
             (d) => d.validatorAddress === v.address
           );
-          invariant(d, "delegation %s must be found in account", v.address);
-          invariant(
-            !canClaimRewards(account as CosmosAccount, d as CosmosDelegation),
-            "reward no longer be claimable"
+          botTest("delegation exists in account", () =>
+            invariant(d, "delegation %s must be found in account", v.address)
+          );
+          botTest("reward is no longer claimable after claim", () =>
+            invariant(
+              !canClaimRewards(account as CosmosAccount, d as CosmosDelegation),
+              "reward no longer be claimable"
+            )
           );
         });
       },

package/src/families/ethereum/hw-signMessage.test.ts

@@ -1,8 +1,10 @@
 import "../../__tests__/test-helpers/setup";
 
-import EIP712Message from "@ledgerhq/hw-app-eth/tests/sample-messages/0.json";
-import hwSignMessage from "./hw-signMessage";
+import { EIP712Message } from "@ledgerhq/hw-app-eth/lib/modules/EIP712";
+import testEIP712Message from "@ledgerhq/hw-app-eth/tests/sample-messages/0.json";
+import ethSign from "./hw-signMessage";
 import { setEnv } from "../../env";
+import { createFixtureCryptoCurrency } from "../../mock/fixtures/cryptoCurrencies";
 
 const signPersonalMessage = jest.fn(() =>
   Promise.resolve({
@@ -25,14 +27,81 @@ const signEIP712Message = jest.fn(() =>
     v: 28,
   })
 );
+// We only need to mock the defaut class returned
 jest.mock("@ledgerhq/hw-app-eth", () => {
-  return class {
-    signPersonalMessage = signPersonalMessage;
-    signEIP712HashedMessage = signEIP712HashedMessage;
-    signEIP712Message = signEIP712Message;
+  const originalModule = jest.requireActual("@ledgerhq/hw-app-eth");
+  return {
+    ...originalModule,
+    default: class {
+      signPersonalMessage = signPersonalMessage;
+      signEIP712HashedMessage = signEIP712HashedMessage;
+      signEIP712Message = signEIP712Message;
+    },
   };
 });
 
+describe("prepareMessageToSign", () => {
+  it("returns a MessageData object when message to sign is a simple string", () => {
+    // Given
+    const currency = createFixtureCryptoCurrency("ethereum");
+    const path = "44'/60'/0'/0/0";
+    const derivationMode = "ethM";
+    const message = "4d6573736167652064652074657374";
+    const expectedRawMessage = "0x4d6573736167652064652074657374";
+
+    // When
+    const result = ethSign.prepareMessageToSign(
+      currency,
+      path,
+      derivationMode,
+      message
+    );
+
+    // Then
+    expect(result).toEqual({
+      currency,
+      path: "44'/60'/0'/0/0",
+      derivationMode: "ethM",
+      message: "Message de test",
+      rawMessage: expectedRawMessage,
+    });
+  });
+
+  it("returns a TypedMessageData object when message to sign is an EIP712Message", () => {
+    // Given
+    const currency = createFixtureCryptoCurrency("ethereum");
+    const path = "44'/60'/0'/0/0";
+    const derivationMode = "ethM";
+    // testEIP712MessageHex
+    const message =
+      "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";
+
+    // When
+    const result = ethSign.prepareMessageToSign(
+      currency,
+      path,
+      derivationMode,
+      message
+    );
+
+    // Then
+    expect(result).toEqual({
+      currency,
+      path,
+      derivationMode,
+      message: testEIP712Message,
+      rawMessage: "0x" + message,
+      hashes: {
+        stringHash: "",
+        domainHash:
+          "0x6137beb405d9ff777172aa879e33edb34a1460e701802746c5ef96e741710e59",
+        messageHash:
+          "0x5476346eb09179b1f7d245c11a27ae6c498a419d7fad4d984d5b1e0ad081662a",
+      },
+    });
+  });
+});
+
 describe("Eth hw-signMessage", () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -40,7 +109,7 @@ describe("Eth hw-signMessage", () => {
 
   describe("parsing", () => {
     it("should be using the signPersonalMessage method with string message", async () => {
-      await hwSignMessage({} as any, {
+      await ethSign.signMessage({} as any, {
         path: "",
         message: "test",
         rawMessage: "0xtest",
@@ -50,32 +119,47 @@ describe("Eth hw-signMessage", () => {
     });
 
     it("should be using the signEIP712HashedMessage method with stringified message", async () => {
-      await hwSignMessage({} as any, {
+      await ethSign.signMessage({} as any, {
         path: "",
-        message: JSON.stringify(EIP712Message),
+        message: JSON.stringify(testEIP712Message),
         rawMessage: "0xtest",
       });
 
       expect(signEIP712HashedMessage).toHaveBeenCalledTimes(1);
     });
 
-    it("should be using the signEIP712Message method with stringified message", async () => {
-      setEnv("EXPERIMENTAL_EIP712", true);
-
-      await hwSignMessage({} as any, {
+    it("should be using the signEIP712HashedMessage method with EIP712Message message", async () => {
+      await ethSign.signMessage({} as any, {
         path: "",
-        message: EIP712Message,
+        message: testEIP712Message as EIP712Message,
         rawMessage: "0xtest",
       });
 
-      expect(signEIP712Message).toHaveBeenCalledTimes(1);
-      setEnv("EXPERIMENTAL_EIP712", false);
+      expect(signEIP712HashedMessage).toHaveBeenCalledTimes(1);
+    });
+
+    describe("when EXPERIMENTAL_EIP712 env variable is set to true", () => {
+      beforeAll(() => {
+        setEnv("EXPERIMENTAL_EIP712", true);
+      });
+
+      afterAll(() => {
+        setEnv("EXPERIMENTAL_EIP712", false);
+      });
+
+      it("should be using the signEIP712Message method with EIP712Message message", async () => {
+        await ethSign.signMessage({} as any, {
+          path: "",
+          message: testEIP712Message as EIP712Message,
+          rawMessage: "0xtest",
+        });
+      });
     });
   });
 
   describe("value of v", () => {
     it("should returning parity for signPersonalMessage", async () => {
-      const { rsv } = await hwSignMessage({} as any, {
+      const { rsv } = await ethSign.signMessage({} as any, {
         path: "",
         message: "test",
         rawMessage: "0xtest",
@@ -85,9 +169,9 @@ describe("Eth hw-signMessage", () => {
     });
 
     it("should not be returning parity for signEIP712HashedMessage", async () => {
-      const { rsv } = await hwSignMessage({} as any, {
+      const { rsv } = await ethSign.signMessage({} as any, {
         path: "",
-        message: JSON.stringify(EIP712Message),
+        message: JSON.stringify(testEIP712Message),
         rawMessage: "0xtest",
       });
 
@@ -97,9 +181,9 @@ describe("Eth hw-signMessage", () => {
     it("should not be returning parity for signEIP712Message", async () => {
       setEnv("EXPERIMENTAL_EIP712", true);
 
-      const { rsv } = await hwSignMessage({} as any, {
+      const { rsv } = await ethSign.signMessage({} as any, {
         path: "",
-        message: EIP712Message,
+        message: testEIP712Message,
         rawMessage: "0xtest",
       });
 

package/src/families/ethereum/hw-signMessage.ts

@@ -1,15 +1,20 @@
+import Eth, { isEIP712Message } from "@ledgerhq/hw-app-eth";
 import { EIP712Message } from "@ledgerhq/hw-app-eth/lib/modules/EIP712/EIP712.types";
-import Eth from "@ledgerhq/hw-app-eth";
 import Transport from "@ledgerhq/hw-transport";
 import { TypedDataUtils } from "eth-sig-util";
 import { bufferToHex } from "ethereumjs-util";
 import { getEnv } from "../../env";
 import type { MessageData, Result } from "../../hw/signMessage/types";
 import type { TypedMessageData } from "./types";
-type EthResolver = (
-  arg0: Transport,
-  arg1: Pick<MessageData | TypedMessageData, "path" | "message"> &
-    Partial<Pick<MessageData, "rawMessage">>
+import { DerivationMode } from "../../derivation";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+type EthSignMessage = (
+  transport: Transport,
+  message: Pick<
+    MessageData | TypedMessageData,
+    "path" | "message" | "rawMessage"
+  >
 ) => Promise<Result>;
 
 export const domainHash = (message: EIP712Message): Buffer => {
@@ -29,18 +34,65 @@ export const messageHash = (message: EIP712Message): Buffer => {
   );
 };
 
-const resolver: EthResolver = async (
-  transport,
-  { path, message, rawMessage }
+function tryConvertToJSON(message: string): string | EIP712Message {
+  try {
+    const parsedMessage = JSON.parse(message);
+    if (isEIP712Message(parsedMessage)) {
+      return parsedMessage as EIP712Message;
+    }
+  } catch {
+    // Not a JSON message
+  }
+  return message;
+}
+
+const prepareMessageToSign = (
+  currency: CryptoCurrency,
+  path: string,
+  derivationMode: DerivationMode,
+  message: string
+): MessageData | TypedMessageData => {
+  const hexToStringMessage = Buffer.from(message, "hex").toString();
+  const parsedMessage = tryConvertToJSON(hexToStringMessage);
+
+  const messageData = {
+    currency,
+    path,
+    derivationMode,
+    rawMessage: "0x" + message,
+  };
+  if (typeof parsedMessage === "string") {
+    return {
+      ...messageData,
+      message: parsedMessage,
+    };
+  } else {
+    return {
+      ...messageData,
+      message: parsedMessage,
+      hashes: {
+        stringHash: "",
+        domainHash: bufferToHex(domainHash(parsedMessage)),
+        messageHash: bufferToHex(messageHash(parsedMessage)),
+      },
+    };
+  }
+};
+
+type PartialMessageData = {
+  path: string;
+  message: string | EIP712Message;
+  rawMessage: string;
+};
+const signMessage: EthSignMessage = async (
+  transport: Transport,
+  { path, message, rawMessage }: PartialMessageData
 ) => {
   const eth = new Eth(transport);
-  const parsedMessage = (() => {
-    try {
-      return JSON.parse(message as string);
-    } catch (e) {
-      return message;
-    }
-  })();
+  let parsedMessage = message;
+  if (typeof message === "string") {
+    parsedMessage = tryConvertToJSON(message);
+  }
 
   let result: Awaited<ReturnType<typeof eth.signPersonalMessage>>;
   if (typeof parsedMessage === "string") {
@@ -70,4 +122,4 @@ const resolver: EthResolver = async (
   };
 };
 
-export default resolver;
+export default { prepareMessageToSign, signMessage };

package/src/families/ethereum/types.ts

@@ -1,15 +1,15 @@
-import { EIP712Message } from "@ledgerhq/hw-app-eth/lib/modules/EIP712/EIP712.types";
 import type { BigNumber } from "bignumber.js";
+import { EIP712Message } from "@ledgerhq/hw-app-eth/lib/modules/EIP712/EIP712.types";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
 import type { TransactionMode, ModeModule } from "./modules";
 import type { Range, RangeRaw } from "../../range";
-import type { DerivationMode } from "../../derivation";
 import type {
   TransactionCommon,
   TransactionCommonRaw,
   TransactionStatusCommon,
   TransactionStatusCommonRaw,
 } from "@ledgerhq/types-live";
-import type { CryptoCurrency, Unit } from "@ledgerhq/types-cryptoassets";
+import type { MessageData } from "../../hw/signMessage/types";
 
 export type EthereumGasLimitRequest = {
   from?: string;
@@ -61,14 +61,12 @@ export type TransactionRaw = TransactionCommonRaw & {
   collectionName?: string;
   quantities?: string[];
 };
-export type TypedMessageData = {
-  currency: CryptoCurrency;
-  path: string;
-  verify?: boolean;
-  derivationMode: DerivationMode;
+export type TypedMessageData = Omit<MessageData, "message"> & {
   message: EIP712Message;
   hashes: {
     stringHash: string;
+    domainHash: string;
+    messageHash: string;
   };
 };
 

package/src/families/filecoin/__snapshots__/bridge.integration.test.ts.snap

@@ -2,6 +2,32 @@
 
 exports[`filecoin currency bridge scanAccounts filecoin seed 1 1`] = `
 Array [
+  Object {
+    "balance": "1000000000000000",
+    "currencyId": "filecoin",
+    "derivationMode": "gliflegacy",
+    "freshAddress": "t15lauyzdivqj7m3yob3rxmzdsy7uyhfflwyheuri",
+    "freshAddressPath": "44'/1'/0'/0/0",
+    "freshAddresses": Array [
+      Object {
+        "address": "t15lauyzdivqj7m3yob3rxmzdsy7uyhfflwyheuri",
+        "derivationPath": "44'/1'/0'/0/0",
+      },
+    ],
+    "id": "js:2:filecoin:t15lauyzdivqj7m3yob3rxmzdsy7uyhfflwyheuri:gliflegacy",
+    "index": 0,
+    "name": "Filecoin 1",
+    "nfts": undefined,
+    "operationsCount": 0,
+    "pendingOperations": Array [],
+    "seedIdentifier": "04ca7b02cafdf36e8b4caaf530a96b949764af71b956b2a3328b7a10940794c860f574a9199be98bde3c261887fec8e5fd94bc5f104908bf5f992f52ef2a89abb0",
+    "spendableBalance": "1000000000000000",
+    "starred": false,
+    "swapHistory": Array [],
+    "syncHash": undefined,
+    "unitMagnitude": 18,
+    "used": true,
+  },
   Object {
     "balance": "100000000000000000",
     "currencyId": "filecoin",
@@ -59,6 +85,7 @@ Array [
 
 exports[`filecoin currency bridge scanAccounts filecoin seed 1 2`] = `
 Array [
+  Array [],
   Array [
     Object {
       "accountId": "js:2:filecoin:f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a:",

package/src/families/filecoin/bridge.integration.test.ts

@@ -31,9 +31,13 @@ const filecoin: CurrenciesData<Transaction> = {
       => 06010000142c000080cd010080000000800000000000000000
       <= 04ca7b02cafdf36e8b4caaf530a96b949764af71b956b2a3328b7a10940794c860f574a9199be98bde3c261887fec8e5fd94bc5f104908bf5f992f52ef2a89abb015017ff83e316c2605c018ab3a6126d5d8ce0a3023e529663170373464346d6c6d657963346167666c686a71736e766f797a796664616937666d6b79736f32619000
       => 0600000000
-      <= 0000160200330000049000
+      <= 0000160500311000049000
       => 06010000142c00008001000080000000800000000000000000
-      <= 04433296b4adc4c68ae79f6ed6ff1b09875c932d993a20dd068b07346c2dcefe42a791287afae0932dea2ded54982e9a4ca38e614a60f320c68ddb554949953094150111b66c4555016c4ea8677f4d71c954a869790d1a2974316367336779726b7661667765356b64687035677864736b757662757873646932686e7377646d699000
+      <= 04d493dab3ff63d6f0673454f8f6d6adec08db19e8c0298c65cfcace76a10757774afdee518b15a8b82452531bcb7860eefce02a89ef9051037646f5d4d6bd74171501eac14c6468ac13f66f0e0ee3766472c7e98394ab297431356c6175797a646976716a376d33796f623372786d7a6473793775796866666c777968657572699000
+      => 0600000000
+      <= 0000160500311000049000
+      => 06010000142c00008001000080000000800000000001000000
+      <= 040cbb57791d797268e34340565393f8a014ae754026159973fbe46bdcef3b6d28d155f4923256a2beb9bcff3bd39e5066d1c778306f28a2d4faa3a66dbf70453e150148c9b66fef1fce116652099bec6301ced31e56472974316a6465336d33377064376862637a737362676e36797979627a336a7234767368676370696b32619000
       => 0600000000
       <= 0000160500311000049000
       => 06010000142c000080cd010080000000800000000001000000

package/src/families/filecoin/hw-signMessage.ts

@@ -1,10 +1,10 @@
 import Fil from "@zondax/ledger-filecoin";
 import { log } from "@ledgerhq/logs";
 
-import type { Resolver, Result } from "../../hw/signMessage/types";
+import type { SignMessage, Result } from "../../hw/signMessage/types";
 import { getBufferFromString, getPath, isError } from "./utils";
 
-const resolver: Resolver = async (
+const signMessage: SignMessage = async (
   transport,
   { path, message }
 ): Promise<Result> => {
@@ -27,4 +27,4 @@ const resolver: Resolver = async (
   };
 };
 
-export default resolver;
+export default { signMessage };

package/src/families/osmosis/specs.ts

@@ -192,13 +192,15 @@ const osmosis: AppSpec<Transaction> = {
             (d) => d.validatorAddress === v.address
           );
           invariant(d, "delegated %s must be found in account", v.address);
-          expect({
-            address: v.address,
-            amount: approximateValue(v.amount),
-          }).toMatchObject({
-            address: (d as CosmosDelegation).validatorAddress,
-            amount: approximateValue((d as CosmosDelegation).amount),
-          });
+          botTest("delegator have planned address and amount", () =>
+            expect({
+              address: v.address,
+              amount: approximateValue(v.amount),
+            }).toMatchObject({
+              address: (d as CosmosDelegation).validatorAddress,
+              amount: approximateValue((d as CosmosDelegation).amount),
+            })
+          );
         });
       },
     },
@@ -260,13 +262,15 @@ const osmosis: AppSpec<Transaction> = {
             (d) => d.validatorAddress === v.address
           );
           invariant(d, "undelegated %s must be found in account", v.address);
-          expect({
-            address: v.address,
-            amount: approximateValue(v.amount),
-          }).toMatchObject({
-            address: (d as CosmosUnbonding).validatorAddress,
-            amount: approximateValue((d as CosmosUnbonding).amount),
-          });
+          botTest("validator have planned address and amount", () =>
+            expect({
+              address: v.address,
+              amount: approximateValue(v.amount),
+            }).toMatchObject({
+              address: (d as CosmosUnbonding).validatorAddress,
+              amount: approximateValue((d as CosmosUnbonding).amount),
+            })
+          );
         });
       },
     },
@@ -338,13 +342,15 @@ const osmosis: AppSpec<Transaction> = {
                   d.validatorSrcAddress === transaction.sourceValidator
               );
             invariant(d, "redelegated %s must be found in account", v.address);
-            expect({
-              address: v.address,
-              amount: approximateValue(v.amount),
-            }).toMatchObject({
-              address: (d as CosmosRedelegation).validatorDstAddress,
-              amount: approximateValue((d as CosmosRedelegation).amount),
-            });
+            botTest("validator have planned address and amount", () =>
+              expect({
+                address: v.address,
+                amount: approximateValue(v.amount),
+              }).toMatchObject({
+                address: (d as CosmosRedelegation).validatorDstAddress,
+                amount: approximateValue((d as CosmosRedelegation).amount),
+              })
+            );
           }
         });
       },
@@ -385,10 +391,14 @@ const osmosis: AppSpec<Transaction> = {
           const d = (cosmosResources as CosmosResources).delegations.find(
             (d) => d.validatorAddress === v.address
           );
-          invariant(d, "delegation %s must be found in account", v.address);
-          invariant(
-            !canClaimRewards(account as CosmosAccount, d as CosmosDelegation),
-            "reward no longer be claimable"
+          botTest("delegation exists in account", () =>
+            invariant(d, "delegation %s must be found in account", v.address)
+          );
+          botTest("reward is no longer claimable after claim", () =>
+            invariant(
+              !canClaimRewards(account as CosmosAccount, d as CosmosDelegation),
+              "reward no longer be claimable"
+            )
           );
         });
       },

package/src/families/stellar/api/horizon.ts

@@ -191,21 +191,21 @@ export const fetchOperations = async ({
       .includeFailed(true)
       .join("transactions")
       .call();
-  } catch (e: any) {
+  } catch (e: unknown) {
     // FIXME: terrible hacks, because Stellar SDK fails to cast network failures to typed errors in react-native...
     // (https://github.com/stellar/js-stellar-sdk/issues/638)
-    const errorMsg = e ? e.toString() : "";
+    const errorMsg = e ? String(e) : "";
 
     if (e instanceof NotFoundError || errorMsg.match(/status code 404/)) {
       return [];
     }
 
     if (errorMsg.match(/status code 4[0-9]{2}/)) {
-      return new LedgerAPI4xx();
+      throw new LedgerAPI4xx();
     }
 
     if (errorMsg.match(/status code 5[0-9]{2}/)) {
-      return new LedgerAPI5xx();
+      throw new LedgerAPI5xx();
     }
 
     if (

package/src/families/tezos/bridge/js.ts

@@ -43,7 +43,7 @@ import { InvalidAddressBecauseAlreadyDelegated } from "../../../errors";
 import api from "../api/tzkt";
 
 const validateRecipient = (currency, recipient) => {
-  let recipientError = null;
+  let recipientError: Error | null = null;
   const recipientWarning = null;
   if (!recipient) {
     recipientError = new RecipientRequired("");

package/src/families/tron/specs.ts

@@ -90,7 +90,7 @@ const tron: AppSpec<Transaction> = {
       },
       test: ({ account }) => {
         botTest("account spendable balance is zero", () =>
-          expect(account.spendableBalance.toString()).toBe("0")
+          expectedApproximate(account.spendableBalance, new BigNumber(0))
         );
       },
     },

package/src/featureFlags/defaultFeatures.ts

@@ -50,9 +50,6 @@ export const defaultFeatures: DefaultFeatures = {
   currencyFlareMobile: {
     enabled: false,
   },
-  currency: {
-    enabled: false,
-  },
   ratings: {
     enabled: false,
     params: {
@@ -103,4 +100,13 @@ export const defaultFeatures: DefaultFeatures = {
   counterValue: {
     enabled: false,
   },
+  llmUsbFirmwareUpdate: {
+    enabled: false,
+  },
+  ptxSmartRouting: {
+    enabled: false,
+  },
+  ptxSmartRoutingMobile: {
+    enabled: false,
+  },
 };

package/src/hw/connectApp.ts

@@ -359,7 +359,7 @@ const cmd = ({
                 return of(e);
               }
             }),
-            catchError((e: Error) => {
+            catchError((e: unknown) => {
               if (
                 e instanceof DisconnectedDeviceDuringOperation ||
                 e instanceof DisconnectedDevice

package/src/hw/connectManager.ts

@@ -83,7 +83,7 @@ const cmd = ({
               listApps(transport, deviceInfo)
             );
           }),
-          catchError((e: Error) => {
+          catchError((e: unknown) => {
             if (
               e instanceof DeviceOnDashboardExpected ||
               (e &&