@ledgerhq/live-common 34.3.0-nightly.9 → 35.0.0-next.6

package/src/families/tron/signOperation.ts

@@ -2,7 +2,6 @@ import { Observable } from "rxjs";
 import BigNumber from "bignumber.js";
 import { AccountBridge, TokenAccount } from "@ledgerhq/types-live";
 import { buildOptimisticOperation } from "./buildOptimisticOperation";
-import { TronSendTrc20ToNewAccountForbidden } from "./errors";
 import signTransaction from "../../hw/signTransaction";
 import { Transaction, TronAccount } from "./types";
 import { withDevice } from "../../hw/deviceAccess";
@@ -10,7 +9,6 @@ import { getEstimatedFees } from "./logic";
 import {
   claimRewardTronTransaction,
   createTronTransaction,
-  fetchTronAccount,
   fetchTronContract,
   freezeTronTransaction,
   legacyUnfreezeTronTransaction,
@@ -43,19 +41,6 @@ export const signOperation: AccountBridge<Transaction, TronAccount>["signOperati
             transaction.amount = balance; // force the amount to be the max
           }
 
-          // send trc20 to a new account is forbidden by us (because it will not activate the account)
-          if (
-            transaction.recipient &&
-            transaction.mode === "send" &&
-            subAccount &&
-            subAccount.type === "TokenAccount" &&
-            subAccount.token.tokenType === "trc20" &&
-            !isContractAddressRecipient && // send trc20 to a smart contract is allowed
-            (await fetchTronAccount(transaction.recipient)).length === 0
-          ) {
-            throw new TronSendTrc20ToNewAccountForbidden();
-          }
-
           const {
             raw_data_hex: rawDataHex,
             raw_data: rawData,

package/src/families/tron/synchronization.ts

@@ -53,7 +53,7 @@ export const getAccountShape: GetAccountShape<TronAccount> = async (
   const spendableBalance = acc.balance ? new BigNumber(acc.balance) : new BigNumber(0);
   const cacheTransactionInfoById = initialAccount
     ? {
-        ...(initialAccount.tronResources.cacheTransactionInfoById || {}),
+        ...(initialAccount?.tronResources?.cacheTransactionInfoById || {}),
       }
     : {};
   const operationsPageSize = Math.min(
@@ -140,9 +140,10 @@ export const getAccountShape: GetAccountShape<TronAccount> = async (
     return accumulator;
   }, []);
 
+  const { blacklistedTokenIds = [] } = syncConfig;
+
   const subAccounts: SubAccount[] = compact(
     trc10Tokens.concat(trc20Tokens).map(({ key, tokenId, balance }) => {
-      const { blacklistedTokenIds = [] } = syncConfig;
       const token = findTokenById(tokenId);
       if (!token || blacklistedTokenIds.includes(tokenId)) return;
       const id = encodeTokenAccountId(accountId, token);
@@ -167,6 +168,16 @@ export const getAccountShape: GetAccountShape<TronAccount> = async (
       return sub;
     }),
   );
+
+  // Filter blacklisted tokens from the initial account's subAccounts
+  // Could be use to filter out tokens that got their CAL id changed
+  const filteredInitialSubAccounts = (initialAccount?.subAccounts || []).filter(
+    subAccount => !blacklistedTokenIds.includes(subAccount.token.id),
+  );
+
+  // keep old account with emptyBalance and a history not returned by the BE fixes LIVE-12797
+  const mergedSubAccounts = mergeSubAccounts(subAccounts, filteredInitialSubAccounts);
+
   // get 'OUT' token operations with fee
   const subOutOperationsWithFee: TronOperation[] = subAccounts
     .flatMap(s => s.operations)
@@ -199,7 +210,7 @@ export const getAccountShape: GetAccountShape<TronAccount> = async (
     spendableBalance,
     operationsCount: parentOpsAndSubOutOpsWithFee.length,
     operations: parentOpsAndSubOutOpsWithFee,
-    subAccounts,
+    subAccounts: mergedSubAccounts,
     tronResources,
     blockHeight,
   };
@@ -225,4 +236,35 @@ export const postSync = (initial: TronAccount, parent: TronAccount): TronAccount
   return parent;
 };
 
+/**
+ * Merges two arrays of subAccounts according to specific rules:
+ * - The first array (subAccounts1) is up-to-date and should not be modified.
+ * - Old duplicates from the second array (subAccounts2) should be filtered out.
+ * - Only new subAccounts with a unique ID from the second array should be included.
+ * - The balance and spendableBalance fields of the second array's subAccounts should be set to 0.
+ *
+ * @param {Array} subAccounts1 - The first array of subAccounts, which is up-to-date and should not be modified.
+ * @param {Array} subAccounts2 - The second array of subAccounts, from which only new unique subAccounts should be included.
+ * @returns {Array} - The merged array of subAccounts.
+ */
+const mergeSubAccounts = (subAccounts1, subAccounts2) => {
+  const existingIds = new Set(subAccounts1.map(subAccount => subAccount.id));
+  const filteredSubAccounts2 = subAccounts2
+    .map(subAccount => {
+      if (existingIds.has(subAccount.id)) {
+        return null;
+      } else {
+        // Set balance and spendableBalance to 0 has if they are not here it means balance is 0
+        return {
+          ...subAccount,
+          balance: new BigNumber(0),
+          spendableBalance: new BigNumber(0),
+        };
+      }
+    })
+    .filter(subAccount => subAccount !== null);
+
+  return subAccounts1.concat(filteredSubAccounts2);
+};
+
 export const sync = makeSync({ getAccountShape, postSync });

package/src/featureFlags/defaultFeatures.ts

@@ -71,7 +71,11 @@ export const CURRENCY_DEFAULT_FEATURES = {
   currencyCasper: DEFAULT_FEATURE,
   currencyNeonEvm: DEFAULT_FEATURE,
   currencyLinea: DEFAULT_FEATURE,
-  currencyLineaTesnet: DEFAULT_FEATURE,
+  currencyLineaSepolia: DEFAULT_FEATURE,
+  currencyBlast: DEFAULT_FEATURE,
+  currencyBlastSepolia: DEFAULT_FEATURE,
+  currencyScroll: DEFAULT_FEATURE,
+  currencyScrollSepolia: DEFAULT_FEATURE,
 };
 
 /**
@@ -92,7 +96,6 @@ export const DEFAULT_FEATURES: Features = {
   disableNftLedgerMarket: DEFAULT_FEATURE,
   disableNftRaribleOpensea: DEFAULT_FEATURE,
   disableNftSend: DEFAULT_FEATURE,
-  staxWelcomeScreen: DEFAULT_FEATURE,
   listAppsV2minor1: DEFAULT_FEATURE,
   flexibleContentCards: DEFAULT_FEATURE,
   ethStakingProviders: initFeature(),
@@ -412,6 +415,8 @@ export const DEFAULT_FEATURES: Features = {
   },
 
   ptxSwapMoonpayProvider: DEFAULT_FEATURE,
+  ptxSwapExodusProvider: DEFAULT_FEATURE,
+  ptxSwapThorswapProvider: DEFAULT_FEATURE,
 
   llmAnalyticsOptInPrompt: {
     enabled: false,
@@ -455,7 +460,6 @@ export const DEFAULT_FEATURES: Features = {
 
   lldChatbotSupport: DEFAULT_FEATURE,
   llmChatbotSupport: DEFAULT_FEATURE,
-  supportDeviceStax: DEFAULT_FEATURE,
   supportDeviceEuropa: DEFAULT_FEATURE,
   lldRefreshMarketData: {
     ...DEFAULT_FEATURE,
@@ -463,8 +467,15 @@ export const DEFAULT_FEATURES: Features = {
       refreshTime: 3, //nb minutes
     },
   },
+  llmRefreshMarketData: {
+    ...DEFAULT_FEATURE,
+    params: {
+      refreshTime: 3, //nb minutes
+    },
+  },
   spamReportNfts: DEFAULT_FEATURE,
   lldWalletSync: DEFAULT_FEATURE,
+  llmWalletSync: DEFAULT_FEATURE,
   lldNftsGalleryNewArch: DEFAULT_FEATURE,
 };
 

package/src/featureFlags/groupedFeatures.ts

@@ -1,15 +1,14 @@
 import { FeatureId } from "@ledgerhq/types-live";
 
+export type GroupedFeature = "europa" | "disableNft";
+
 /** Helper to group several feature flag ids under a common feature flag */
 export const groupedFeatures: Record<
-  string,
+  GroupedFeature,
   {
     featureIds: FeatureId[];
   }
 > = {
-  stax: {
-    featureIds: ["supportDeviceStax", "deviceInitialApps", "staxWelcomeScreen"],
-  },
   europa: {
     featureIds: ["supportDeviceEuropa", "deviceInitialApps"],
   },

package/src/helpers.ts

@@ -9,3 +9,9 @@ export function includes<T extends U, U>(array: ReadonlyArray<T>, element: U): e
 export function objectKeysType<Type extends object>(value: Type): Array<keyof Type> {
   return Object.keys(value) as Array<keyof Type>;
 }
+
+export function reverseRecord<T extends PropertyKey, U extends PropertyKey>(
+  input: Record<T, U>,
+): Record<U, T> {
+  return Object.fromEntries(Object.entries(input).map(([key, value]) => [value, key]));
+}

package/src/hw/getOnboardingStatePolling.ts

@@ -8,7 +8,7 @@ import {
   DeviceExtractOnboardingStateError,
   DisconnectedDevice,
   CantOpenDevice,
-  TransportPendingOperation,
+  TransportRaceCondition,
   LockedDeviceError,
   UnexpectedBootloader,
   TransportExchangeTimeoutError,
@@ -139,7 +139,7 @@ export const isAllowedOnboardingStatePollingError = (error: unknown): boolean =>
       error instanceof DisconnectedDevice ||
       error instanceof DisconnectedDeviceDuringOperation ||
       error instanceof CantOpenDevice ||
-      error instanceof TransportPendingOperation ||
+      error instanceof TransportRaceCondition ||
       error instanceof TransportStatusError ||
       // A locked device is handled as an allowed error
       error instanceof LockedDeviceError)

package/src/market/api/index.ts

@@ -0,0 +1,138 @@
+import network from "@ledgerhq/live-network/network";
+import { getEnv } from "@ledgerhq/live-env";
+import {
+  MarketCurrencyChartDataRequestParams,
+  MarketListRequestParams,
+  MarketPerformersParams,
+  MarketItemResponse,
+  SupportedCoins,
+  MarketCurrencyRequestParams,
+  MarketCoinDataChart,
+  Order,
+} from "../utils/types";
+import { rangeDataTable } from "../utils/rangeDataTable";
+import URL from "url";
+import { getRange, getSortParam } from "../utils";
+
+const baseURL = () => getEnv("LEDGER_COUNTERVALUES_API");
+const ROOT_PATH = getEnv("MARKET_API_URL");
+
+export async function getSupportedCoinsList(): Promise<SupportedCoins> {
+  const url = `${ROOT_PATH}/coins/list`;
+  const { data } = await network({ method: "GET", url });
+  return data;
+}
+
+// fetches currencies data for selected currencies ids
+export async function fetchList({
+  counterCurrency,
+  limit = 50,
+  page = 1,
+  order = Order.MarketCapDesc,
+  search = "",
+  liveCoinsList = [],
+  starred = [],
+  range = "24",
+}: MarketListRequestParams): Promise<MarketItemResponse[]> {
+  const url = URL.format({
+    pathname: `${baseURL()}/v3/markets`,
+    query: {
+      page: page,
+      pageSize: limit,
+      to: counterCurrency,
+      sort: getSortParam(order, range),
+      ...(search.length >= 1 && { filter: search }),
+      ...(starred.length > 0 && { ids: starred.join(",") }),
+      ...(liveCoinsList.length > 1 && { ids: liveCoinsList.join(",") }),
+      ...([Order.topLosers, Order.topGainers].includes(order) && { top: 100 }),
+    },
+  });
+
+  const { data } = await network({
+    method: "GET",
+    url,
+  });
+
+  return data;
+}
+
+// Fetches list of supported counterCurrencies
+export async function supportedCounterCurrencies(): Promise<string[]> {
+  const url = `${ROOT_PATH}/simple/supported_vs_currencies`;
+
+  const { data } = await network({
+    method: "GET",
+    url,
+  });
+
+  return data;
+}
+
+export async function fetchCurrencyChartData({
+  id,
+  counterCurrency,
+  range = "24h",
+}: MarketCurrencyChartDataRequestParams): Promise<MarketCoinDataChart> {
+  const { days, interval } = rangeDataTable[range];
+
+  const url = URL.format({
+    pathname: `${ROOT_PATH}/coins/${id}/market_chart`,
+    query: {
+      vs_currency: counterCurrency,
+      days,
+      interval,
+    },
+  });
+
+  const { data } = await network({
+    method: "GET",
+    url,
+  });
+
+  return { [range]: data.prices };
+}
+
+export async function fetchCurrency({
+  counterCurrency,
+  id,
+}: MarketCurrencyRequestParams): Promise<MarketItemResponse> {
+  const url = URL.format({
+    pathname: `${baseURL()}/v3/markets`,
+    query: {
+      to: counterCurrency,
+      ids: id,
+      pageSize: 1,
+      limit: 1,
+    },
+  });
+
+  const { data } = await network({ method: "GET", url });
+
+  return data[0];
+}
+
+export async function fetchMarketPerformers({
+  counterCurrency,
+  range,
+  limit = 5,
+  top = 50,
+  sort,
+  supported,
+}: MarketPerformersParams): Promise<MarketItemResponse[]> {
+  const sortParam = `${sort === "asc" ? "positive" : "negative"}-price-change-${getRange(range)}`;
+
+  const url = URL.format({
+    pathname: `${baseURL()}/v3/markets`,
+    query: {
+      to: counterCurrency,
+      limit,
+      top,
+      sort: sortParam,
+      supported,
+    },
+  });
+
+  const { data } = await network({ method: "GET", url });
+
+  return data;
+}

package/src/market/{v2 → hooks}/useMarketDataProvider.ts

@@ -2,26 +2,28 @@ import { UseQueryResult, useQueries, useQuery } from "@tanstack/react-query";
 import {
   fetchCurrency,
   fetchCurrencyChartData,
-  fetchCurrencyData,
   fetchList,
   getSupportedCoinsList,
   supportedCounterCurrencies,
-} from "../api/api";
+} from "../api";
+import { listCryptoCurrencies } from "@ledgerhq/cryptoassets/currencies";
+import { listTokens } from "@ledgerhq/cryptoassets/tokens";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+import { useMemo } from "react";
+import { listSupportedCurrencies } from "../../currencies";
+import { currencyFormatter, format } from "../utils/currencyFormatter";
+import { QUERY_KEY } from "../utils/queryKeys";
+import { REFETCH_TIME_ONE_MINUTE, BASIC_REFETCH, ONE_DAY } from "../utils/timers";
 import {
-  CurrencyData,
-  HashMapBody,
   MarketCurrencyRequestParams,
   MarketListRequestParams,
+  CurrencyData,
+  HashMapBody,
+  MarketItemResponse,
   MarketListRequestResult,
-  RawCurrencyData,
-} from "../types";
-import { QUERY_KEY } from "./queryKeys";
-import { listCryptoCurrencies, listSupportedCurrencies, listTokens } from "../../currencies";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { useMemo } from "react";
-
-import { currencyFormatter, format } from "../utils/currencyFormatter";
-import { BASIC_REFETCH, ONE_DAY, REFETCH_TIME_ONE_MINUTE } from "./timers";
+  Order,
+} from "../utils/types";
 
 const cryptoCurrenciesList = [...listCryptoCurrencies(), ...listTokens()];
 
@@ -57,26 +59,15 @@ export const useCurrencyChartData = ({ id, counterCurrency, range }: MarketCurre
     staleTime: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
   });
 
-export function useCurrencyData({ id, counterCurrency, range }: MarketCurrencyRequestParams) {
-  const resultCurrencyData = useQuery({
-    queryKey: [QUERY_KEY.CurrencyData, id, counterCurrency, range],
-    queryFn: () => fetchCurrencyData({ counterCurrency, range, id }),
-    refetchInterval: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
-    staleTime: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
-    select: (data: RawCurrencyData) => format(data, range ?? "24h", cryptoCurrenciesList),
-  });
-
-  const resultCurrency = useQuery({
-    queryKey: [QUERY_KEY.CurrencyDataRaw, id],
-    queryFn: () => fetchCurrency({ id }),
+export const useCurrencyData = ({ id, counterCurrency }: MarketCurrencyRequestParams) =>
+  useQuery({
+    queryKey: [QUERY_KEY.CurrencyDataRaw, id, counterCurrency],
+    queryFn: () => fetchCurrency({ id, counterCurrency }),
     refetchInterval: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
     staleTime: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
-    select: data => format(data, "24h", cryptoCurrenciesList),
+    select: data => format(data, cryptoCurrenciesList),
   });
 
-  return { currencyData: resultCurrencyData, currencyInfo: resultCurrency };
-}
-
 export const useSupportedCounterCurrencies = () =>
   useQuery({
     queryKey: [QUERY_KEY.SupportedCounterCurrencies],
@@ -95,14 +86,24 @@ export const useSupportedCurrencies = () =>
 
 export function useMarketData(props: MarketListRequestParams): MarketListRequestResult {
   return useQueries({
-    queries: Array.from({ length: props.page ?? 1 }, (_, i) => i + 1).map(page => ({
+    queries: Array.from({ length: props.page ?? 1 }, (_, i) => i).map(page => ({
       queryKey: [
         QUERY_KEY.MarketData,
-        { ...props, page, liveCoinsList: [], supportedCoinsList: [] },
+        page,
+        props.order,
+        {
+          counterCurrency: props.counterCurrency,
+          ...(props.search && props.search?.length >= 1 && { search: props.search }),
+          ...(props.starred && props.starred?.length >= 1 && { starred: props.starred }),
+          ...(props.liveCoinsList &&
+            props.liveCoinsList?.length >= 1 && { liveCoinsList: props.liveCoinsList }),
+          ...(props.order &&
+            [Order.topLosers, Order.topGainers].includes(props.order) && { range: props.range }),
+        },
       ],
       queryFn: () => fetchList({ ...props, page }),
-      select: (data: RawCurrencyData[]) => ({
-        formattedData: currencyFormatter(data, props.range ?? "24h", cryptoCurrenciesList),
+      select: (data: MarketItemResponse[]) => ({
+        formattedData: currencyFormatter(data, cryptoCurrenciesList),
         page,
       }),
       refetchOnMount: false,

package/src/market/{v2 → hooks}/useMarketPerformers.ts

@@ -1,9 +1,9 @@
-import { fetchMarketPerformers } from "../api/api";
-import { MarketItemPerformer, MarketItemResponse, MarketPerformersParams } from "../types";
-import { QUERY_KEY } from "./queryKeys";
+import { fetchMarketPerformers } from "../api";
+import { MarketItemPerformer, MarketItemResponse, MarketPerformersParams } from "../utils/types";
+import { QUERY_KEY } from "../utils/queryKeys";
 import { UseQueryResult, useQuery } from "@tanstack/react-query";
 import { formatPerformer } from "../utils/currencyFormatter";
-import { REFETCH_TIME_ONE_MINUTE } from "./timers";
+import { REFETCH_TIME_ONE_MINUTE } from "../utils/timers";
 
 export const useMarketPerformers = ({
   counterCurrency,

package/src/market/utils/currencyFormatter.ts

@@ -1,11 +1,11 @@
 import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import {
   CurrencyData,
+  KeysPriceChange,
   MarketItemPerformer,
   MarketItemResponse,
-  RawCurrencyData,
   SparklineSvgData,
-} from "../types";
+} from "./types";
 
 function distributedCopy(items: number[], n: number): number[] {
   if (!items) return [];
@@ -46,42 +46,46 @@ function sparklineAsSvgData(points: number[]): SparklineSvgData {
 }
 
 export function currencyFormatter(
-  data: RawCurrencyData[],
-  range: string,
+  data: MarketItemResponse[],
   cryptoCurrenciesList: (CryptoCurrency | TokenCurrency)[],
 ): CurrencyData[] {
-  return data.map((currency: RawCurrencyData) => format(currency, range, cryptoCurrenciesList));
+  return data.map((currency: MarketItemResponse) => format(currency, cryptoCurrenciesList));
 }
 
 export const format = (
-  currency: RawCurrencyData,
-  range: string,
+  currency: MarketItemResponse,
   cryptoCurrenciesList: (CryptoCurrency | TokenCurrency)[],
-) => ({
+): CurrencyData => ({
   id: currency.id,
   name: currency.name,
-  image: typeof currency.image === "string" ? currency.image : currency.image?.thumb,
+  image: currency.image,
   internalCurrency: cryptoCurrenciesList.find(
-    ({ ticker }) => ticker.toLowerCase() === currency.symbol,
+    ({ ticker }) => ticker.toLowerCase() === currency.ticker,
   ),
-  marketcap: currency.market_cap,
-  marketcapRank: currency.market_cap_rank,
-  totalVolume: currency.total_volume,
-  high24h: currency.high_24h,
-  low24h: currency.low_24h,
-  ticker: currency.symbol,
-  price: currency.current_price,
-  priceChangePercentage: currency[`price_change_percentage_${range}_in_currency`],
-  marketCapChangePercentage24h: currency.market_cap_change_percentage_24h,
-  circulatingSupply: currency.circulating_supply,
-  totalSupply: currency.total_supply,
-  maxSupply: currency.max_supply,
-  ath: currency.ath,
-  athDate: currency.ath_date,
-  atl: currency.atl,
-  atlDate: currency.atl_date,
-  sparklineIn7d: currency?.sparkline_in_7d?.price
-    ? sparklineAsSvgData(distributedCopy(currency.sparkline_in_7d.price, 6 * 7)) // keep 6 points per day
+  marketcap: currency.marketCap,
+  marketcapRank: currency.marketCapRank,
+  totalVolume: currency.totalVolume,
+  high24h: currency.high24h,
+  low24h: currency.low24h,
+  ticker: currency.ticker,
+  price: currency.price,
+  priceChangePercentage: {
+    [KeysPriceChange.hour]: currency.priceChangePercentage1h,
+    [KeysPriceChange.day]: currency.priceChangePercentage24h,
+    [KeysPriceChange.week]: currency.priceChangePercentage7d,
+    [KeysPriceChange.month]: currency.priceChangePercentage30d,
+    [KeysPriceChange.year]: currency.priceChangePercentage1y,
+  },
+  marketCapChangePercentage24h: currency.marketCapChangePercentage24h,
+  circulatingSupply: currency.circulatingSupply,
+  totalSupply: currency.totalSupply,
+  maxSupply: currency.maxSupply,
+  ath: currency.allTimeHigh,
+  athDate: new Date(currency.allTimeHighDate),
+  atl: currency.allTimeLow,
+  atlDate: new Date(currency.allTimeLowDate),
+  sparklineIn7d: currency.sparkline
+    ? sparklineAsSvgData(distributedCopy(currency.sparkline, 6 * 7)) // keep 6 points per day
     : undefined,
   chartData: {},
 });

package/src/market/utils/index.ts

@@ -0,0 +1,34 @@
+import { PortfolioRange } from "@ledgerhq/types-live";
+import { Order } from "./types";
+
+export function getRange(range: PortfolioRange | string) {
+  switch (range) {
+    case "day":
+    case "24h":
+      return "1d";
+    case "7d":
+    case "week":
+      return "1w";
+    case "30d":
+    case "month":
+      return "1m";
+    case "1y":
+    case "year":
+    case "all":
+      return "1y";
+  }
+}
+
+export const getSortParam = (order: Order, range: PortfolioRange | string) => {
+  switch (order) {
+    default:
+    case Order.MarketCapDesc:
+      return "market-cap-rank";
+    case Order.MarketCapAsc:
+      return "market-cap-rank-desc";
+    case Order.topLosers:
+      return `negative-price-change-${getRange(range)}`;
+    case Order.topGainers:
+      return `positive-price-change-${getRange(range)}`;
+  }
+};