@ledgerhq/live-common 34.46.0-nightly.3 → 34.46.0-nightly.5

package/src/families/hedera/constants.ts

@@ -0,0 +1,2 @@
+// Encapsulate for LLD & LLM
+export * from "@ledgerhq/coin-hedera/constants";

package/src/families/hedera/setup.ts

@@ -4,17 +4,21 @@ import { createBridges } from "@ledgerhq/coin-hedera/bridge/index";
 import Transport from "@ledgerhq/hw-transport";
 import Hedera from "@ledgerhq/hw-app-hedera";
 import hederaResolver from "@ledgerhq/coin-hedera/signer/index";
-import type { Account, Bridge } from "@ledgerhq/types-live";
+import type {
+  TransactionStatus,
+  Transaction,
+  HederaAccount,
+} from "@ledgerhq/coin-hedera/types/index";
+import type { Bridge } from "@ledgerhq/types-live";
 import makeCliTools from "@ledgerhq/coin-hedera/test/cli";
 import { CreateSigner, createResolver, executeWithSigner } from "../../bridge/setup";
 import { Resolver } from "../../hw/getAddress/types";
-import { TransactionStatus, Transaction } from "@ledgerhq/coin-hedera/types/index";
 
 const createSigner: CreateSigner<Hedera> = (transport: Transport) => {
   return new Hedera(transport);
 };
 
-const bridge: Bridge<Transaction, Account, TransactionStatus> = createBridges(
+const bridge: Bridge<Transaction, HederaAccount, TransactionStatus> = createBridges(
   executeWithSigner(createSigner),
 );
 

package/src/families/solana/setup.ts

@@ -19,6 +19,7 @@ import { SolanaCoinConfig } from "@ledgerhq/coin-solana/config";
 import { getCryptoCurrencyById } from "../../currencies";
 import { signMessage } from "@ledgerhq/coin-solana/hw-signMessage";
 import { LegacySignerSolana } from "@ledgerhq/live-signer-solana";
+import { getCryptoAssetsStore } from "../../bridge/crypto-assets";
 
 const createSigner: CreateSigner<SolanaSigner> = (transport: Transport) =>
   new LegacySignerSolana(transport);
@@ -30,6 +31,7 @@ const getCurrencyConfig = () => {
 const bridge: Bridge<Transaction, SolanaAccount, TransactionStatus> = createBridges(
   executeWithSigner(createSigner),
   getCurrencyConfig,
+  getCryptoAssetsStore,
 );
 
 const messageSigner = {

package/src/featureFlags/defaultFeatures.ts

@@ -625,6 +625,7 @@ export const DEFAULT_FEATURES: Features = {
     },
   },
   lldModularDrawerBackendData: DEFAULT_FEATURE,
+  llmModularDrawerBackendData: DEFAULT_FEATURE,
   llmModularDrawer: {
     ...DEFAULT_FEATURE,
     params: {

package/src/market/utils/countervalueFormatter.ts

@@ -12,7 +12,6 @@ export const counterValueFormatter = ({
   if (!value) {
     return "-";
   }
-
   return new Intl.NumberFormat(locale, {
     style: currency ? "currency" : "decimal",
     currency,

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

@@ -1,5 +1,5 @@
-import { getCryptoCurrencyById } from "@ledgerhq/live-common/currencies/index";
 import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { getCryptoCurrencyById } from "../../currencies";
 
 export const mockBtcCryptoCurrency = getCryptoCurrencyById("bitcoin");
 export const mockEthCryptoCurrency = getCryptoCurrencyById("ethereum");

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

@@ -1,4 +1,4 @@
-import { LoadingStatus } from "@ledgerhq/live-common/deposit/type";
+import { LoadingStatus } from "../../deposit/type";
 import {
   arbitrumToken,
   mockArbitrumCryptoCurrency,

package/src/modularDrawer/data/entities/index.ts

@@ -0,0 +1,79 @@
+import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { ApiAsset } from "@ledgerhq/cryptoassets";
+import { PartialMarketItemResponse } from "@ledgerhq/live-common/market/utils/types";
+
+// Types for crypto asset metadata
+export interface CryptoAssetMeta {
+  /** Asset identifier */
+  id: string;
+  /** Asset ticker symbol */
+  ticker: string;
+  /** Asset display name */
+  name: string;
+  /** Map of network IDs to their corresponding asset IDs */
+  assetsIds: Record<string, string>;
+}
+
+// Types for network information
+export interface NetworkInfo {
+  /** Network identifier */
+  id: string;
+  /** Network display name */
+  name: string;
+}
+
+// Types for interest rate data
+export interface InterestRate {
+  /** Currency identifier */
+  currencyId: string;
+  /** Interest rate value */
+  rate: number;
+  /** Type of rate (NRR, APR, APY, etc.) */
+  type: string;
+  /** Timestamp when the rate was fetched */
+  fetchAt: string;
+}
+
+// Types for currency ordering
+export interface CurrenciesOrder {
+  /** Sorting key (e.g., "marketCap") */
+  key: string;
+  /** Sort order (e.g., "desc") */
+  order: string;
+  /** Ordered list of currency IDs */
+  currenciesIds: string[];
+  /** Ordered list of meta-currency IDs */
+  metaCurrencyIds: string[];
+}
+
+// Types for raw API response (before transformation)
+export interface RawApiResponse {
+  /** Grouped crypto assets by meta-currency */
+  cryptoAssets: Record<string, CryptoAssetMeta>;
+  /** Network information */
+  networks: Record<string, NetworkInfo>;
+  /** Raw crypto currencies and token currencies from API */
+  cryptoOrTokenCurrencies: Record<string, ApiAsset>;
+  /** Interest rates for various currencies */
+  interestRates: Record<string, InterestRate>;
+  /** Market data for currencies */
+  markets: Record<string, PartialMarketItemResponse>;
+  /** Currency ordering information */
+  currenciesOrder: CurrenciesOrder;
+}
+
+// Types for transformed API response (after transformation)
+export interface AssetsData {
+  /** Grouped crypto assets by meta-currency */
+  cryptoAssets: Record<string, CryptoAssetMeta>;
+  /** Network information */
+  networks: Record<string, NetworkInfo>;
+  /** Transformed crypto currencies and token currencies compatible with Ledger Live */
+  cryptoOrTokenCurrencies: Record<string, CryptoOrTokenCurrency>;
+  /** Interest rates for various currencies */
+  interestRates: Record<string, InterestRate>;
+  /** Market data for currencies */
+  markets: Record<string, PartialMarketItemResponse>;
+  /** Currency ordering information */
+  currenciesOrder: CurrenciesOrder;
+}

package/src/modularDrawer/data/state-manager/api.ts

@@ -0,0 +1,62 @@
+import { createApi, fetchBaseQuery, FetchBaseQueryMeta } from "@reduxjs/toolkit/query/react";
+import { convertApiAssets } from "@ledgerhq/cryptoassets";
+import { AssetsData, RawApiResponse } from "../entities";
+import { getEnv } from "@ledgerhq/live-env";
+
+export enum AssetsDataTags {
+  Assets = "Assets",
+}
+
+export interface GetAssetsDataParams {
+  cursor?: string;
+  search?: string;
+  currencyIds?: string[];
+}
+
+export interface AssetsDataWithPagination extends AssetsData {
+  pagination: {
+    nextCursor?: string;
+  };
+}
+
+function transformAssetsResponse(
+  response: RawApiResponse,
+  meta?: FetchBaseQueryMeta,
+): AssetsDataWithPagination {
+  const enrichedCryptoOrTokenCurrencies = convertApiAssets(response.cryptoOrTokenCurrencies);
+
+  const nextCursor = meta?.response?.headers.get("x-ledger-next") || undefined;
+
+  return {
+    ...response,
+    cryptoOrTokenCurrencies: enrichedCryptoOrTokenCurrencies,
+    pagination: {
+      nextCursor,
+    },
+  };
+}
+
+export const assetsDataApi = createApi({
+  reducerPath: "assetsDataApi",
+  baseQuery: fetchBaseQuery({
+    baseUrl: __DEV__ ? getEnv("DADA_API_STAGING") : getEnv("DADA_API_PROD"),
+  }),
+  tagTypes: [AssetsDataTags.Assets],
+  endpoints: build => ({
+    getAssetsData: build.query<AssetsDataWithPagination, GetAssetsDataParams>({
+      query: ({ cursor, search, currencyIds: _currencyIds }) => ({
+        url: "assets",
+        params: {
+          ...(cursor && { cursor }),
+          ...(search && { search }),
+          // ...(currencyIds && currencyIds.length > 0 && { currencyIds }),
+          pageSize: 100,
+        },
+      }),
+      providesTags: [AssetsDataTags.Assets],
+      transformResponse: transformAssetsResponse,
+    }),
+  }),
+});
+
+export const { useGetAssetsDataQuery } = assetsDataApi;

package/src/modularDrawer/hooks/__test__/useAssetsData.test.ts

@@ -0,0 +1,139 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { renderHook } from "@testing-library/react";
+import { useAssetsData } from "../useAssetsData";
+import { useGetAssetsDataQuery } from "../../data/state-manager/api";
+
+jest.mock("../../data/state-manager/api", () => ({
+  useGetAssetsDataQuery: jest.fn(),
+}));
+
+const mockSetCursor = jest.fn();
+jest.mock("react", () => ({
+  ...jest.requireActual("react"),
+  useState: jest.fn(() => [undefined, mockSetCursor]),
+  useCallback: jest.fn(fn => fn),
+  useMemo: jest.fn(fn => fn()),
+}));
+
+const mockUseGetAssetsDataQuery = jest.mocked(useGetAssetsDataQuery);
+
+describe("useAssetsData", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return loading state when API is loading", () => {
+    mockUseGetAssetsDataQuery.mockReturnValue({
+      data: undefined,
+      isLoading: true,
+      error: undefined,
+      refetch: jest.fn(),
+      isFetching: false,
+      isSuccess: false,
+      isError: false,
+      currentData: undefined,
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.isLoading).toBe(true);
+    expect(result.current.data).toBe(undefined);
+    expect(result.current.hasMore).toBe(false);
+  });
+
+  it("should return data and hasMore when API returns data", () => {
+    const mockData = {
+      assetsData: [],
+      pagination: { nextCursor: "test-cursor" },
+    };
+    mockUseGetAssetsDataQuery.mockReturnValue({
+      data: mockData,
+      isLoading: false,
+      error: undefined,
+      refetch: jest.fn(),
+      isFetching: false,
+      isSuccess: true,
+      isError: false,
+      currentData: mockData,
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.data).toBe(mockData);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.hasMore).toBe(true);
+  });
+
+  it("should return error when API has error", () => {
+    const mockError = new Error("API Error");
+    mockUseGetAssetsDataQuery.mockReturnValue({
+      data: undefined,
+      isLoading: false,
+      error: mockError,
+      refetch: jest.fn(),
+      isFetching: false,
+      isSuccess: false,
+      isError: true,
+      currentData: undefined,
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.error).toBe(mockError);
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  it("should call setCursor when loadNext is called and there's a nextCursor", () => {
+    const nextCursor = "next-cursor-456";
+    mockUseGetAssetsDataQuery.mockReturnValue({
+      data: {
+        assetsData: [],
+        pagination: { nextCursor },
+      },
+      isLoading: false,
+      error: undefined,
+      refetch: jest.fn(),
+      isFetching: false,
+      isSuccess: true,
+      isError: false,
+      currentData: {
+        assetsData: [],
+        pagination: { nextCursor },
+      },
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    result.current.loadNext();
+
+    expect(mockSetCursor).toHaveBeenCalledWith(nextCursor);
+  });
+
+  it("should not call setCursor when there's no nextCursor", () => {
+    mockUseGetAssetsDataQuery.mockReturnValue({
+      data: {
+        assetsData: [],
+        pagination: { nextCursor: undefined },
+      },
+      isLoading: false,
+      error: undefined,
+      refetch: jest.fn(),
+      isFetching: false,
+      isSuccess: true,
+      isError: false,
+      currentData: {
+        assetsData: [],
+        pagination: { nextCursor: undefined },
+      },
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    result.current.loadNext();
+
+    expect(mockSetCursor).not.toHaveBeenCalled();
+  });
+});

package/src/modularDrawer/hooks/useAssetsData.ts

@@ -0,0 +1,36 @@
+import { useState, useCallback } from "react";
+import { useGetAssetsDataQuery } from "../data/state-manager/api";
+
+export function useAssetsData({
+  search,
+  currencyIds,
+}: {
+  search?: string;
+  currencyIds?: string[];
+}) {
+  const [cursor, setCursor] = useState<string | undefined>(undefined);
+  const { data, error, isLoading, isSuccess } = useGetAssetsDataQuery({
+    cursor,
+    search,
+    currencyIds,
+  });
+
+  const loadNext = useCallback(() => {
+    const nextCursor = data?.pagination?.nextCursor;
+    if (nextCursor) {
+      setCursor(nextCursor);
+    }
+  }, [data?.pagination?.nextCursor]);
+
+  const hasMore = Boolean(data?.pagination?.nextCursor);
+
+  return {
+    data,
+    error,
+    isLoading,
+    isSuccess,
+    hasMore,
+    cursor,
+    loadNext,
+  };
+}