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

package/src/e2e/speculosCI.ts

@@ -21,6 +21,14 @@ function uniqueId(): string {
   return timestamp + randomString;
 }
 
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
 /**
  * Helper function to make API requests with error handling
  */
@@ -58,10 +66,14 @@ async function githubApiRequest<T = unknown>({
   }
 }
 
-function waitForSpeculosReady(url: string, { interval = 2000, timeout = 300_000 } = {}) {
+export function waitForSpeculosReady(
+  deviceId: string,
+  { interval = 2_000, timeout = 150_000 } = {},
+) {
   return new Promise((resolve, reject) => {
     const startTime = Date.now();
     let currentRequest: ReturnType<typeof https.get> | null = null;
+    const url = getSpeculosAddress(deviceId);
 
     function cleanup() {
       if (currentRequest) {
@@ -151,22 +163,22 @@ function createStartPayload(deviceParams: DeviceParams, runId: string) {
 export async function createSpeculosDeviceCI(
   deviceParams: DeviceParams,
 ): Promise<SpeculosDevice | undefined> {
+  const runId = `${slugify(deviceParams.appName)}-${uniqueId()}`;
   try {
-    const runId = uniqueId();
-    console.warn("Creating remote speculos:", runId);
     const data = createStartPayload(deviceParams, runId);
     await githubApiRequest({ urlSuffix: START_WORKFLOW_ID, data });
-    await waitForSpeculosReady(getSpeculosAddress(runId));
-
     return {
       id: runId,
       port: speculosPort,
     };
   } catch (e: unknown) {
-    console.error(e);
     console.warn(
       `Creating remote speculos ${deviceParams.appName}:${deviceParams.appVersion} failed with ${String(e)}`,
     );
+    return {
+      id: runId,
+      port: 0,
+    };
   }
 }
 

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/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,
+  };
+}