@ledgerhq/live-common 34.52.0-nightly.9 → 34.53.0-nightly.20251107095716

package/src/hw/actions/implementations.ts

@@ -10,10 +10,14 @@ import {
   of,
   timer,
 } from "rxjs";
-import { DisconnectedDevice, DisconnectedDeviceDuringOperation } from "@ledgerhq/errors";
+import {
+  DisconnectedDevice,
+  DisconnectedDeviceDuringOperation,
+  LockedDeviceError,
+} from "@ledgerhq/errors";
 import { catchError, debounce, delayWhen, filter, switchMap, tap, timeout } from "rxjs/operators";
 import { Device } from "./types";
-import { getDeviceModel } from "@ledgerhq/devices";
+import { DeviceModelId, getDeviceModel } from "@ledgerhq/devices";
 import { ConnectManagerTimeout } from "../../errors";
 import { LocalTracer } from "@ledgerhq/logs";
 import { LOG_TYPE } from "..";
@@ -73,6 +77,21 @@ export type EmittedEvent<T> = {
   type: string;
 } & T;
 
+const remapError = (error: Error, deviceModelID: DeviceModelId): Error => {
+  if (!(error instanceof TimeoutError)) {
+    return error;
+  }
+
+  if (deviceModelID === DeviceModelId.nanoS) {
+    return new LockedDeviceError();
+  }
+
+  return new ConnectManagerTimeout(undefined, {
+    // TODO make this configurable
+    productName: getDeviceModel(deviceModelID).productName,
+  });
+};
+
 /**
  * Returns a polling implementation function that repeatedly performs a given task
  * with a given request, with a specified polling frequency and wait times until a
@@ -112,8 +131,6 @@ const pollingImplementation: Implementation = <SpecificType, GenericRequestType>
     // Runs every time we get a new device.
     function actionLoop() {
       if (currentDevice) {
-        const productName = getDeviceModel(currentDevice.modelId).productName;
-
         connectSub = concat(
           of({
             type: "deviceChange",
@@ -144,13 +161,7 @@ const pollingImplementation: Implementation = <SpecificType, GenericRequestType>
             }),
 
             catchError((error: Error) => {
-              const maybeRemappedError =
-                error instanceof TimeoutError
-                  ? (new ConnectManagerTimeout(undefined, {
-                      // TODO make this configurable
-                      productName,
-                    }) as Error)
-                  : error;
+              const maybeRemappedError = remapError(error, currentDevice.modelId);
 
               tracer.trace(`Error when running task in polling implementation: ${error}`, {
                 error,

package/src/hw/connectAppEventMapper.ts

@@ -12,11 +12,9 @@ import type {
 import {
   DeviceActionStatus,
   DeviceDisconnectedWhileSendingError,
-  DeviceLockedError,
   DeviceSessionStateType,
   UserInteractionRequired,
   OutOfMemoryDAError,
-  SecureChannelError,
   UnsupportedFirmwareDAError,
 } from "@ledgerhq/device-management-kit";
 import type {
@@ -254,10 +252,10 @@ export class ConnectAppEventMapper {
             deviceState.firmwareUpdateContext!.currentFirmware.version,
         }),
       );
-    } else if (error instanceof DeviceLockedError) {
+    } else if ("_tag" in error && error._tag === "DeviceLockedError") {
       this.eventSubject.next({ type: "lockedDevice" });
       this.eventSubject.complete();
-    } else if (error instanceof SecureChannelError) {
+    } else if ("_tag" in error && error._tag === "RefusedByUserDAError") {
       this.eventSubject.error(new UserRefusedAllowManager());
     } else if (error instanceof DeviceDisconnectedWhileSendingError) {
       this.eventSubject.next({ type: "disconnected", expected: false });

package/src/market/hooks/useMarketDataProvider.ts

@@ -6,8 +6,6 @@ import {
   getSupportedCoinsList,
   supportedCounterCurrencies,
 } from "../api";
-import { listCryptoCurrencies } from "@ledgerhq/cryptoassets/currencies";
-import { listTokens } from "@ledgerhq/cryptoassets/tokens";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 import { useMemo } from "react";
@@ -18,15 +16,13 @@ import { REFETCH_TIME_ONE_MINUTE, BASIC_REFETCH, ONE_DAY } from "../utils/timers
 import {
   MarketCurrencyRequestParams,
   MarketListRequestParams,
-  CurrencyData,
+  MarketCurrencyData,
   HashMapBody,
   MarketItemResponse,
   MarketListRequestResult,
   Order,
 } from "../utils/types";
 
-const cryptoCurrenciesList = [...listCryptoCurrencies(), ...listTokens()];
-
 export function useMarketDataProvider() {
   const supportedCurrenciesInLIve = listSupportedCurrencies();
 
@@ -65,7 +61,7 @@ export const useCurrencyData = ({ id, counterCurrency }: MarketCurrencyRequestPa
     queryFn: () => fetchCurrency({ id, counterCurrency }),
     refetchInterval: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
     staleTime: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
-    select: data => format(data, cryptoCurrenciesList),
+    select: data => format(data),
   });
 
 export const useSupportedCounterCurrencies = () =>
@@ -104,7 +100,7 @@ export function useMarketData(props: MarketListRequestParams): MarketListRequest
       ],
       queryFn: () => fetchList({ ...props, page, search }),
       select: (data: MarketItemResponse[]) => ({
-        formattedData: currencyFormatter(data, cryptoCurrenciesList),
+        formattedData: currencyFormatter(data),
         page,
       }),
       refetchOnMount: false,
@@ -118,7 +114,7 @@ export function useMarketData(props: MarketListRequestParams): MarketListRequest
 function combineMarketData(
   results: UseQueryResult<
     {
-      formattedData: CurrencyData[];
+      formattedData: MarketCurrencyData[];
       page: number;
     },
     Error

package/src/market/utils/currencyFormatter.ts

@@ -1,6 +1,5 @@
-import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import {
-  CurrencyData,
+  MarketCurrencyData,
   KeysPriceChange,
   MarketItemPerformer,
   MarketItemResponse,
@@ -45,29 +44,16 @@ function sparklineAsSvgData(points: number[]): SparklineSvgData {
   };
 }
 
-export function currencyFormatter(
-  data: MarketItemResponse[],
-  cryptoCurrenciesList: (CryptoCurrency | TokenCurrency)[],
-): CurrencyData[] {
-  return data.map((currency: MarketItemResponse) => format(currency, cryptoCurrenciesList));
+export function currencyFormatter(data: MarketItemResponse[]): MarketCurrencyData[] {
+  return data.map((currency: MarketItemResponse) => format(currency));
 }
 
-export const format = (
-  currency: MarketItemResponse,
-  cryptoCurrenciesList?: (CryptoCurrency | TokenCurrency)[],
-): CurrencyData => {
-  const ledgerIdsSet = new Set(currency.ledgerIds.map(id => id.toLowerCase()));
-
-  const internalCurrency = cryptoCurrenciesList?.find(({ id }) =>
-    ledgerIdsSet.has(id.toLowerCase()),
-  );
-
+export const format = (currency: MarketItemResponse): MarketCurrencyData => {
   return {
     id: currency.id,
     ledgerIds: currency.ledgerIds,
     name: currency.name,
     image: currency.image,
-    internalCurrency,
     marketcap: currency.marketCap,
     marketcapRank: currency.marketCapRank,
     totalVolume: currency.totalVolume,

package/src/market/utils/queryKeys.ts

@@ -1,5 +1,4 @@
 export const QUERY_KEY = {
-  CurrencyData: "CurrencyData",
   CurrencyDataRaw: "CurrencyDataRaw",
   CurrencyChartData: "CurrencyChartData",
   SupportedCounterCurrencies: "SupportedCounterCurrencies",

package/src/market/utils/types.ts

@@ -1,4 +1,3 @@
-import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { RefetchOptions, QueryObserverResult } from "@tanstack/react-query";
 import { PortfolioRange } from "@ledgerhq/types-live";
 
@@ -33,7 +32,7 @@ export type MarketListRequestParams = {
 };
 
 export type MarketListRequestResult = {
-  data: CurrencyData[];
+  data: MarketCurrencyData[];
   isPending: boolean;
   isLoading: boolean;
   isError: boolean;
@@ -45,7 +44,7 @@ export type HashMapBody = {
   refetch: (options?: RefetchOptions | undefined) => Promise<
     QueryObserverResult<
       {
-        formattedData: CurrencyData[];
+        formattedData: MarketCurrencyData[];
         page: number;
       },
       Error
@@ -80,12 +79,11 @@ export enum KeysPriceChange {
   year = "1y",
 }
 
-export type CurrencyData = {
+export type MarketCurrencyData = {
   id: string;
   ledgerIds: string[];
   name: string;
   image?: string;
-  internalCurrency?: CryptoOrTokenCurrency;
   marketcap?: number;
   marketcapRank: number;
   totalVolume: number;
@@ -113,13 +111,13 @@ export type SingleCoinState = {
   loadingChart: boolean;
   error?: Error;
   supportedCounterCurrencies: string[];
-  selectedCoinData?: CurrencyData;
+  selectedCoinData?: MarketCurrencyData;
   counterCurrency?: string;
 };
 
 export type State = SingleCoinState & {
   ready: boolean;
-  marketData?: CurrencyData[];
+  marketData?: MarketCurrencyData[];
   requestParams: MarketListRequestParams;
   page: number;
   endOfList: boolean;
@@ -187,7 +185,7 @@ export type MarketItemPerformer = {
 
 export type MarketDataApi = {
   setSupportedCoinsList: () => Promise<SupportedCoins>;
-  listPaginated: (params: MarketListRequestParams) => Promise<CurrencyData[]>;
+  listPaginated: (params: MarketListRequestParams) => Promise<MarketCurrencyData[]>;
   supportedCounterCurrencies: () => Promise<string[]>;
   currencyChartData: (
     params: MarketCurrencyChartDataRequestParams,

package/src/mock/fixtures/cryptoCurrencies.ts

@@ -1,7 +1,7 @@
 import BigNumber from "bignumber.js";
 import type { CoinType, CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { TokenAccount, Account } from "@ledgerhq/types-live";
-import { cryptocurrenciesById, findTokenById } from "@ledgerhq/cryptoassets";
+import { cryptocurrenciesById } from "@ledgerhq/cryptoassets";
 import { CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
 
 export function createFixtureCryptoCurrency(family: string): CryptoCurrency {
@@ -38,7 +38,16 @@ export function createFixtureCryptoCurrency(family: string): CryptoCurrency {
 }
 
 const defaultEthCryptoFamily = cryptocurrenciesById["ethereum"];
-const defaultERC20USDTToken = findTokenById("ethereum/erc20/usd_tether__erc20_")!;
+const defaultERC20USDTToken: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/usd_tether__erc20_",
+  name: "Tether USD (ERC-20)",
+  ticker: "USDT",
+  units: [{ name: "Tether USD", code: "USDT", magnitude: 6 }],
+  contractAddress: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+  parentCurrency: defaultEthCryptoFamily,
+  tokenType: "erc20",
+};
 
 export function createFixtureTokenAccount(
   id = "00",

package/src/modularDrawer/__mocks__/currencies.mock.ts

@@ -83,7 +83,7 @@ export const maticBsc: TokenCurrency = {
 };
 export const findCryptoCurrencyById = (id: string) =>
   [mockBtcCryptoCurrency, mockEthCryptoCurrency, mockArbitrumCryptoCurrency].find(a => a.id === id);
-export const getTokenOrCryptoCurrencyById = (id: string) =>
+export const getTokenOrCryptoCurrencyById = async (id: string) =>
   [
     mockBtcCryptoCurrency,
     mockEthCryptoCurrency,

package/src/modularDrawer/utils/__tests__/currencyUtils.test.ts

@@ -17,12 +17,12 @@ import {
 } from "../../__mocks__/currencies.mock";
 
 describe("safeCurrencyLookup", () => {
-  it("should return the currency if it is found", () => {
-    const currency = safeCurrencyLookup("ethereum");
+  it("should return the currency if it is found", async () => {
+    const currency = await safeCurrencyLookup("ethereum");
     expect(currency).toBeDefined();
   });
-  it("should return null if the currency is not found", () => {
-    const currency = safeCurrencyLookup("not-a-currency");
+  it("should return null if the currency is not found", async () => {
+    const currency = await safeCurrencyLookup("not-a-currency");
     expect(currency).toBeNull();
   });
 });
@@ -55,14 +55,14 @@ describe("isProviderToken", () => {
 });
 
 describe("getProviderCurrency", () => {
-  it("should return the currency if it is a provider currency", () => {
+  it("should return the currency if it is a provider currency", async () => {
     const { result } = useGroupedCurrenciesByProvider();
-    const currency = getProviderCurrency(result.currenciesByProvider[0]);
+    const currency = await getProviderCurrency(result.currenciesByProvider[0]);
     expect(currency).toEqual(mockBtcCryptoCurrency);
   });
-  it("should return the currency if it is a provider token", () => {
+  it("should return the currency if it is a provider token", async () => {
     const { result } = useGroupedCurrenciesByProvider();
-    const currency = getProviderCurrency(result.currenciesByProvider[3]);
+    const currency = await getProviderCurrency(result.currenciesByProvider[3]);
     expect(currency).toEqual(usdcToken);
   });
 });
@@ -115,9 +115,9 @@ describe("filterProvidersByIds", () => {
 });
 
 describe("extractProviderCurrencies", () => {
-  it("should extract provider currencies correctly", () => {
+  it("should extract provider currencies correctly", async () => {
     const { result } = useGroupedCurrenciesByProvider();
-    const providerCurrencies = extractProviderCurrencies(result.currenciesByProvider);
+    const providerCurrencies = await extractProviderCurrencies(result.currenciesByProvider);
     expect(providerCurrencies).toHaveLength(5);
     expect(providerCurrencies[0]).toEqual(mockBtcCryptoCurrency);
     expect(providerCurrencies[1].id).toBe("ethereum");

package/src/modularDrawer/utils/currencyUtils.ts

@@ -4,9 +4,10 @@ import { isTokenCurrency } from "../../currencies";
 import { CurrenciesByProviderId } from "../../deposit/type";
 
 export type ProviderCoverageMap = Map<string, Set<string>>;
-export const safeCurrencyLookup = (id: string): CryptoOrTokenCurrency | null => {
+
+export const safeCurrencyLookup = async (id: string): Promise<CryptoOrTokenCurrency | null> => {
   try {
-    return getTokenOrCryptoCurrencyById(id);
+    return await getTokenOrCryptoCurrencyById(id);
   } catch {
     return null;
   }
@@ -16,9 +17,9 @@ export const isProviderToken = (currency: CryptoOrTokenCurrency, providerId: str
   return isTokenCurrency(currency) && currency.id.toLowerCase().includes(providerId.toLowerCase());
 };
 
-export const getProviderCurrency = (
+export const getProviderCurrency = async (
   provider: CurrenciesByProviderId,
-): CryptoOrTokenCurrency | null => {
+): Promise<CryptoOrTokenCurrency | null> => {
   const providerToken = provider.currenciesByNetwork.find(currency => {
     return isProviderToken(currency, provider.providerId);
   });
@@ -27,7 +28,8 @@ export const getProviderCurrency = (
     return providerToken;
   }
 
-  return safeCurrencyLookup(provider.providerId) ?? provider.currenciesByNetwork[0];
+  const lookupResult = await safeCurrencyLookup(provider.providerId);
+  return lookupResult ?? provider.currenciesByNetwork[0];
 };
 
 export const buildProviderCoverageMap = (
@@ -85,10 +87,9 @@ export const filterProvidersByIds = (
   return filtered;
 };
 
-export const extractProviderCurrencies = (
+export const extractProviderCurrencies = async (
   providers: CurrenciesByProviderId[],
-): CryptoOrTokenCurrency[] => {
-  return providers
-    .map(provider => getProviderCurrency(provider))
-    .filter((currency): currency is CryptoOrTokenCurrency => currency !== null);
+): Promise<CryptoOrTokenCurrency[]> => {
+  const currencies = await Promise.all(providers.map(provider => getProviderCurrency(provider)));
+  return currencies.filter((currency): currency is CryptoOrTokenCurrency => currency !== null);
 };

package/src/platform/serializers.test.ts

@@ -22,7 +22,7 @@ const SIGNED_TRANSACTION: SignedOperation = {
     date: new Date("2021-08-24T12:33:40.584Z"),
     value: new BigNumber("1"),
     fee: new BigNumber("2091600000000000"),
-    transactionSequenceNumber: 15,
+    transactionSequenceNumber: BigNumber(15),
   },
   signature:
     "0xf8640f850f75bf9800827b0c943f87926741ecaXXXXXXXXXXXXXXXXXXXXXXXXXXX018025a058693cad6ee2299f034ffa04287faba5e777b30659e5bb29bcefdb8284285c97a022169e3ec2a894a35c6edf4223ca6cb3c24453cea78d474d29d1252a236e132b",
@@ -42,7 +42,7 @@ const RAW_SIGNED_TRANSACTION: SignedOperationRaw = {
     date: "2021-08-24T12:33:40.584Z",
     value: "1",
     fee: "2091600000000000",
-    transactionSequenceNumber: 15,
+    transactionSequenceNumber: "15",
   },
   signature:
     "0xf8640f850f75bf9800827b0c943f87926741ecaXXXXXXXXXXXXXXXXXXXXXXXXXXX018025a058693cad6ee2299f034ffa04287faba5e777b30659e5bb29bcefdb8284285c97a022169e3ec2a894a35c6edf4223ca6cb3c24453cea78d474d29d1252a236e132b",

package/src/postOnboarding/hooks/usePostOnboardingHubState.test.ts

@@ -4,7 +4,11 @@
 import { useFeatureFlags } from "../../featureFlags";
 import { hubStateSelector } from "../reducer";
 import { usePostOnboardingContext } from "./usePostOnboardingContext";
-import { getPostOnboardingAction, mockedFeatureIdToTest } from "../mock";
+import {
+  getPostOnboardingAction,
+  mockedFeatureIdToTest,
+  mockedFeatureParamIdToTest,
+} from "../mock";
 import { renderHook } from "@testing-library/react";
 import { DeviceModelId } from "@ledgerhq/types-devices";
 import { PostOnboardingActionId } from "@ledgerhq/types-live";
@@ -19,10 +23,16 @@ jest.mock("../reducer");
 
 const mockedUseFeatureFlags = jest.mocked(useFeatureFlags);
 
-const mockedGetFeatureWithMockFeatureEnabled = enabled => ({
+const mockedGetFeatureWithMockFeatureEnabled = (enabled, paramEnabled = true) => ({
   isFeature: () => true,
   getFeature: id => {
-    if (id === mockedFeatureIdToTest) return { enabled };
+    if (id === mockedFeatureIdToTest)
+      return {
+        enabled,
+        params: {
+          [mockedFeatureParamIdToTest]: paramEnabled,
+        },
+      };
     return { enabled: true };
   },
   overrideFeature: () => {},
@@ -134,6 +144,23 @@ describe("usePostOnboardingHubState", () => {
     expect(lastActionCompleted).toBe(null);
   });
 
+  it("should not return actions that have a disabled feature param flag ", () => {
+    const state = stateAllCompleted;
+    mockedHubStateSelector.mockReturnValue(state);
+    mockedUseFeatureFlags.mockReturnValue(mockedGetFeatureWithMockFeatureEnabled(true, false));
+
+    const {
+      result: {
+        current: { actionsState, lastActionCompleted },
+      },
+    } = renderHook(() => usePostOnboardingHubState());
+
+    expect(actionsState.find(action => action.featureFlagId === mockedFeatureIdToTest)).toBe(
+      undefined,
+    );
+    expect(lastActionCompleted).toBe(null);
+  });
+
   it("should return actions that have a feature flag enabled", () => {
     const state = stateAllCompleted;
     mockedHubStateSelector.mockReturnValue(state);

package/src/postOnboarding/hooks/usePostOnboardingHubState.ts

@@ -1,10 +1,23 @@
 import { useSelector } from "react-redux";
 import { useMemo } from "react";
-import { PostOnboardingHubState } from "@ledgerhq/types-live";
-import { useFeatureFlags } from "../../featureFlags";
+import { PostOnboardingAction, PostOnboardingHubState } from "@ledgerhq/types-live";
+import { FeatureFlagsContextValue, useFeatureFlags } from "../../featureFlags";
 import { hubStateSelector } from "../reducer";
 import { usePostOnboardingContext } from "./usePostOnboardingContext";
 
+const getIsFeatureEnabled = (
+  action: PostOnboardingAction | undefined,
+  getFeature: FeatureFlagsContextValue["getFeature"],
+) => {
+  if (!action) return false;
+  if (!action.featureFlagId) return true;
+
+  const flag = getFeature(action.featureFlagId);
+  if (!flag?.enabled) return false;
+
+  return !action.featureFlagParamId || !!flag.params?.[action.featureFlagParamId];
+};
+
 /**
  * @returns an object representing the state that should be rendered on the post
  * onboarding hub screen.
@@ -26,9 +39,12 @@ export function usePostOnboardingHubState(): PostOnboardingHubState {
         actionsState: [],
         postOnboardingInProgress: hubState.postOnboardingInProgress,
       };
+
     const actionsState = hubState.actionsToComplete.flatMap(actionId => {
       const action = getPostOnboardingAction(actionId);
-      if (!action || (action.featureFlagId && !getFeature(action.featureFlagId)?.enabled)) {
+      const isFeatureEnabled = getIsFeatureEnabled(action, getFeature);
+
+      if (!action || !isFeatureEnabled) {
         return [];
       }
       return [{ ...action, completed: !!hubState.actionsCompleted[actionId] }];
@@ -38,9 +54,7 @@ export function usePostOnboardingHubState(): PostOnboardingHubState {
       : null;
 
     const isLastActionCompletedEnabled =
-      lastActionCompleted &&
-      (!lastActionCompleted.featureFlagId ||
-        getFeature(lastActionCompleted.featureFlagId)?.enabled);
+      lastActionCompleted && getIsFeatureEnabled(lastActionCompleted, getFeature);
 
     return {
       deviceModelId: hubState.deviceModelId,

package/src/postOnboarding/mock.ts

@@ -5,6 +5,7 @@ import { FeatureId, PostOnboardingAction, PostOnboardingActionId } from "@ledger
 const MockIcon = () => null;
 
 export const mockedFeatureIdToTest: FeatureId = "mockFeature";
+export const mockedFeatureParamIdToTest: string = "mockFeatureParam";
 
 export const claimTestMock: PostOnboardingAction = {
   id: PostOnboardingActionId.claimMock,
@@ -21,6 +22,7 @@ export const personalizeTestMock: PostOnboardingAction = {
   id: PostOnboardingActionId.personalizeMock,
   Icon: MockIcon,
   featureFlagId: mockedFeatureIdToTest,
+  featureFlagParamId: mockedFeatureParamIdToTest,
   title: `Personalize my device`,
   titleCompleted: `Personalize my device`,
   description: "By customizing the screen.",

package/src/transaction/index.ts

@@ -36,10 +36,10 @@ export const toTransactionStatusRaw = (
   return TM.toTransactionStatusRaw(t as any);
 };
 
-export const formatTransaction = (t: Transaction, a: Account): string => {
+export const formatTransaction = async (t: Transaction, a: Account): Promise<string> => {
   const TM = transactionModulePerFamily[t.family];
   // FIXME: something is wrong with TM.formatTransaction expecting a (arg: never) => for some reasons
-  return TM.formatTransaction ? TM.formatTransaction(t as any, a as any) : "";
+  return TM.formatTransaction ? await TM.formatTransaction(t as any, a as any) : "";
 };
 
 export const formatTransactionStatus = (