@ledgerhq/live-common 34.39.0-nightly.0 → 34.39.0-nightly.2

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/modularDrawer/__test__/useModularDrawerVisibility.test.ts

@@ -0,0 +1,149 @@
+/**
+ * @jest-environment jsdom
+ */
+import { renderHook } from "@testing-library/react";
+import { useModularDrawerVisibility } from "../useModularDrawerVisibility";
+import { ModularDrawerLocation } from "../enums";
+import {
+  makeMockedFeatureFlagsProviderWrapper,
+  makeMockedContextValue,
+} from "../../featureFlags/mock";
+
+describe("useModularDrawerVisibility", () => {
+  describe("lldModularDrawer", () => {
+    it("should return false if the feature flag is not enabled", () => {
+      const mockedFeatures = {
+        lldModularDrawer: {
+          enabled: false,
+          params: { [ModularDrawerLocation.ADD_ACCOUNT]: true },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "lldModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return false if the location param is not set", () => {
+      const mockedFeatures = {
+        lldModularDrawer: { enabled: true, params: {} },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "lldModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return the correct visibility for each location", () => {
+      const mockedFeatures = {
+        lldModularDrawer: {
+          enabled: true,
+          params: {
+            [ModularDrawerLocation.ADD_ACCOUNT]: true,
+            [ModularDrawerLocation.EARN_FLOW]: false,
+          },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "lldModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(true);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.EARN_FLOW)).toBe(false);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.LIVE_APP)).toBe(false);
+    });
+  });
+
+  describe("llmModularDrawer", () => {
+    it("should return false if the feature flag is not enabled", () => {
+      const mockedFeatures = {
+        llmModularDrawer: {
+          enabled: false,
+          params: { [ModularDrawerLocation.ADD_ACCOUNT]: true },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "llmModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return false if the location param is not set", () => {
+      const mockedFeatures = {
+        llmModularDrawer: { enabled: true, params: {} },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "llmModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return the correct visibility for each location", () => {
+      const mockedFeatures = {
+        llmModularDrawer: {
+          enabled: true,
+          params: {
+            [ModularDrawerLocation.ADD_ACCOUNT]: false,
+            [ModularDrawerLocation.EARN_FLOW]: true,
+            [ModularDrawerLocation.RECEIVE_FLOW]: true,
+          },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "llmModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.EARN_FLOW)).toBe(true);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.RECEIVE_FLOW)).toBe(true);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.LIVE_APP)).toBe(false);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.SEND_FLOW)).toBe(false);
+    });
+  });
+});

package/src/modularDrawer/enums.ts

@@ -0,0 +1,7 @@
+export enum ModularDrawerLocation {
+  ADD_ACCOUNT = "add_account",
+  EARN_FLOW = "earn_flow",
+  LIVE_APP = "live_app",
+  RECEIVE_FLOW = "receive_flow",
+  SEND_FLOW = "send_flow",
+}

package/src/modularDrawer/useModularDrawerVisibility.ts

@@ -0,0 +1,25 @@
+import { useCallback } from "react";
+import { useFeature } from "../featureFlags";
+import { ModularDrawerLocation } from "./enums";
+
+type ModularDrawerFeatureFlagKey = "lldModularDrawer" | "llmModularDrawer";
+
+export function useModularDrawerVisibility({
+  modularDrawerFeatureFlagKey,
+}: {
+  modularDrawerFeatureFlagKey: ModularDrawerFeatureFlagKey;
+}) {
+  const featureModularDrawer = useFeature(modularDrawerFeatureFlagKey);
+
+  const isModularDrawerVisible = useCallback(
+    (location: ModularDrawerLocation) => {
+      if (!featureModularDrawer?.enabled) return false;
+      return featureModularDrawer.params?.[location] ?? false;
+    },
+    [featureModularDrawer],
+  );
+
+  return {
+    isModularDrawerVisible,
+  };
+}

package/src/wallet-api/types.ts

@@ -79,7 +79,7 @@ export type RecentlyUsedIdDb = {
 export type CurrentAccountHistIDb = Record<string, string>;
 
 export type DAppTrackingData = {
-  type: "approve" | "transfer";
+  type: string;
   currency: string;
   network: CryptoCurrency["id"];
 };

package/src/wallet-api/useDappLogic.ts

@@ -15,8 +15,8 @@ import BigNumber from "bignumber.js";
 import { safeEncodeEIP55 } from "@ledgerhq/coin-evm/logic";
 import { SmartWebsocket } from "./SmartWebsocket";
 import { stripHexPrefix } from "./helpers";
-import { DeviceTransactionField, getDeviceTransactionConfig } from "../transaction";
-import type { Transaction } from "../generated/types";
+import { getTxType } from "./utils/txTrackingHelper";
+import { Transaction as EvmTransaction } from "@ledgerhq/coin-evm/types/transaction";
 
 type MessageId = number | string | null;
 
@@ -205,16 +205,6 @@ function isParentAccountPresent(
   return true;
 }
 
-function getTransactionType(fields: Array<DeviceTransactionField>): string {
-  for (let i = 0; i < fields.length; i++) {
-    const field = fields[i];
-    if (field.type === "text" && field.label === "Type") {
-      return field.value;
-    }
-  }
-  return "";
-}
-
 export function useDappLogic({
   manifest,
   accounts,
@@ -490,20 +480,7 @@ export function useDappLogic({
                 account: currentAccount,
               });
 
-              const fields = getDeviceTransactionConfig({
-                account: currentAccount,
-                parentAccount: currentParentAccount,
-                transaction: signFlowInfos.liveTx as Transaction,
-                status: {
-                  errors: {},
-                  warnings: {},
-                  estimatedFees: new BigNumber(0),
-                  amount: new BigNumber(0),
-                  totalSpent: new BigNumber(0),
-                },
-              });
-
-              const transactionType = getTransactionType(fields);
+              const transactionType = getTxType(signFlowInfos.liveTx as EvmTransaction);
 
               const token = findTokenByAddress(tx.recipient);
 
@@ -518,7 +495,7 @@ export function useDappLogic({
                   : currentAccount.currency.id;
 
               trackingData = {
-                type: transactionType === "Approve" ? "approve" : "transfer",
+                type: transactionType,
                 currency: token ? token.name : accountCurrencyName,
                 network: token ? token.parentCurrency.id : accountNetwork,
               };

package/src/wallet-api/utils/txTrackingHelper.test.ts

@@ -0,0 +1,80 @@
+import { getTxType } from "./txTrackingHelper";
+import { ERC20_CLEAR_SIGNED_SELECTORS, DAPP_SELECTORS } from "@ledgerhq/hw-app-eth";
+import { Transaction as EvmTransaction } from "@ledgerhq/coin-evm/types/transaction";
+
+const createMockTransaction = (selector: string): EvmTransaction =>
+  ({
+    data: Buffer.from(selector.slice(2) + "0".repeat(128), "hex"),
+    recipient: "0x1234567890123456789012345678901234567890",
+    amount: "0",
+    gasPrice: "0",
+    gasLimit: "21000",
+    nonce: 0,
+  }) as unknown as EvmTransaction;
+
+describe("getTxType", () => {
+  describe("ERC20 transactions", () => {
+    it("should return 'transfer' for ERC20 transfer selector", () => {
+      const tx = createMockTransaction(ERC20_CLEAR_SIGNED_SELECTORS.TRANSFER);
+      const result = getTxType(tx);
+      expect(result).toBe("transfer");
+    });
+
+    it("should return 'approve' for ERC20 approve selector", () => {
+      const tx = createMockTransaction(ERC20_CLEAR_SIGNED_SELECTORS.APPROVE);
+      const result = getTxType(tx);
+      expect(result).toBe("approve");
+    });
+  });
+
+  describe("DAPP transactions", () => {
+    it("should return the DAPP selector value for known DAPP transactions", () => {
+      const dappSelectors = Object.keys(DAPP_SELECTORS);
+      if (dappSelectors.length > 0) {
+        const firstSelector = dappSelectors[0];
+        const expectedValue = DAPP_SELECTORS[firstSelector];
+
+        const tx = createMockTransaction(firstSelector);
+        const result = getTxType(tx);
+        expect(result).toBe(expectedValue);
+      }
+    });
+  });
+
+  describe("Unknown transactions", () => {
+    it("should return 'transfer' for unknown selectors", () => {
+      const tx = createMockTransaction("0x12345678");
+      const result = getTxType(tx);
+      expect(result).toBe("transfer");
+    });
+
+    it("should return 'transfer' for transactions without data", () => {
+      const tx = {
+        data: undefined,
+      } as EvmTransaction;
+      const result = getTxType(tx);
+      expect(result).toBe("transfer");
+    });
+
+    it("should return 'transfer' for transactions with empty data", () => {
+      const tx = {
+        data: Buffer.alloc(0),
+      } as EvmTransaction;
+      const result = getTxType(tx);
+      expect(result).toBe("transfer");
+    });
+  });
+
+  describe("Selector extract", () => {
+    it("should correctly extract 4-byte selector from transaction data", () => {
+      const transferSelector = ERC20_CLEAR_SIGNED_SELECTORS.TRANSFER;
+      const tx = createMockTransaction(transferSelector);
+
+      const expectedSelector = transferSelector;
+      const txSelector = `0x${tx.data?.toString("hex").substring(0, 8)}`;
+
+      expect(txSelector).toBe(expectedSelector);
+      expect(getTxType(tx)).toBe("transfer");
+    });
+  });
+});

package/src/wallet-api/utils/txTrackingHelper.ts

@@ -0,0 +1,14 @@
+import { Transaction as EvmTransaction } from "@ledgerhq/coin-evm/types/transaction";
+import { DAPP_SELECTORS } from "@ledgerhq/hw-app-eth";
+
+const fallback = "transfer";
+
+export const getTxType = (tx: EvmTransaction): string => {
+  if (!tx || !tx.data) return fallback;
+
+  const txSelector = `0x${tx.data.toString("hex").substring(0, 8)}`;
+  const type = DAPP_SELECTORS[txSelector];
+
+  if (!type) return fallback;
+  return type;
+};