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

package/src/dada-client/__mocks__/assets.mock.ts

@@ -0,0 +1,264 @@
+const mockInjectiveCurrency = {
+  type: "CryptoCurrency" as const,
+  id: "injective",
+  name: "Injective",
+  ticker: "INJ",
+  units: [
+    {
+      name: "INJ",
+      code: "INJ",
+      magnitude: 18,
+    },
+  ],
+  family: "injective",
+  managerAppName: "Injective",
+  coinType: 60,
+  scheme: "injective",
+  color: "#00F2FE",
+  explorerViews: [],
+};
+
+const mockEthereumCurrency = {
+  type: "CryptoCurrency" as const,
+  id: "ethereum",
+  name: "Ethereum",
+  ticker: "ETH",
+  units: [],
+  family: "ethereum",
+  managerAppName: "Ethereum",
+  coinType: 60,
+  scheme: "ethereum",
+  color: "#627EEA",
+  explorerViews: [],
+};
+
+const mockBscCurrency = {
+  type: "CryptoCurrency" as const,
+  id: "bsc",
+  name: "Binance Smart Chain",
+  ticker: "BNB",
+  units: [],
+  family: "evm",
+  managerAppName: "Binance Smart Chain",
+  coinType: 60,
+  scheme: "bsc",
+  color: "#F3BA2F",
+  explorerViews: [],
+};
+
+export const mockAssetsData = {
+  cryptoAssets: {
+    "urn:crypto:meta-currency:injective_protocol": {
+      id: "urn:crypto:meta-currency:injective_protocol",
+      ticker: "INJ",
+      name: "Injective",
+      assetsIds: {
+        injective: "injective",
+        ethereum: "ethereum/erc20/injective_token",
+        bsc: "bsc/bep20/injective_protocol",
+      },
+    },
+  },
+  networks: {
+    bsc: { id: "bsc", name: "Binance Smart Chain" },
+    ethereum: { id: "ethereum", name: "Ethereum" },
+    injective: { id: "injective", name: "Injective" },
+  },
+  cryptoOrTokenCurrencies: {
+    "bsc/bep20/injective_protocol": {
+      type: "TokenCurrency" as const,
+      id: "bsc/bep20/injective_protocol",
+      name: "Injective Protocol",
+      ticker: "INJ",
+      contractAddress: "0x0",
+      parentCurrency: mockBscCurrency,
+      tokenType: "bep20",
+      units: [
+        {
+          name: "INJ",
+          code: "INJ",
+          magnitude: 18,
+        },
+      ],
+    },
+    "ethereum/erc20/injective_token": {
+      type: "TokenCurrency" as const,
+      id: "ethereum/erc20/injective_token",
+      name: "Injective Token",
+      ticker: "INJ",
+      contractAddress: "0x0",
+      parentCurrency: mockEthereumCurrency,
+      tokenType: "erc20",
+      units: [
+        {
+          name: "INJ",
+          code: "INJ",
+          magnitude: 18,
+        },
+      ],
+    },
+    injective: mockInjectiveCurrency,
+  },
+  interestRates: {},
+  markets: {},
+  currenciesOrder: {
+    key: "marketCap",
+    order: "desc",
+    currenciesIds: ["injective", "ethereum/erc20/injective_token", "bsc/bep20/injective_protocol"],
+    metaCurrencyIds: ["urn:crypto:meta-currency:injective_protocol"],
+  },
+};
+
+export const mockAssetsDataWithPagination = {
+  ...mockAssetsData,
+  pagination: {
+    nextCursor: "cursor-1",
+  },
+};
+
+// Bitcoin mock data
+const mockBitcoinCurrency = {
+  type: "CryptoCurrency" as const,
+  id: "bitcoin",
+  name: "Bitcoin",
+  ticker: "BTC",
+  units: [
+    {
+      name: "BTC",
+      code: "BTC",
+      magnitude: 8,
+    },
+  ],
+  family: "bitcoin",
+  managerAppName: "Bitcoin",
+  coinType: 0,
+  scheme: "bitcoin",
+  color: "#FF9900",
+  explorerViews: [],
+};
+
+export const mockBitcoinAssetsData = {
+  cryptoAssets: {
+    bitcoin: {
+      id: "bitcoin",
+      ticker: "BTC",
+      name: "Bitcoin",
+      assetsIds: {
+        bitcoin: "bitcoin",
+        ethereum: "ethereum/erc20/wrapped_bitcoin",
+      },
+    },
+  },
+  networks: {
+    bitcoin: { id: "bitcoin", name: "Bitcoin" },
+    ethereum: { id: "ethereum", name: "Ethereum" },
+  },
+  cryptoOrTokenCurrencies: {
+    bitcoin: mockBitcoinCurrency,
+    "ethereum/erc20/wrapped_bitcoin": {
+      type: "TokenCurrency" as const,
+      id: "ethereum/erc20/wrapped_bitcoin",
+      name: "Wrapped Bitcoin",
+      ticker: "WBTC",
+      contractAddress: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+      parentCurrency: mockEthereumCurrency,
+      tokenType: "erc20",
+      units: [
+        {
+          name: "WBTC",
+          code: "WBTC",
+          magnitude: 8,
+        },
+      ],
+    },
+  },
+  interestRates: {},
+  markets: {},
+  currenciesOrder: {
+    key: "marketCap",
+    order: "desc",
+    currenciesIds: ["bitcoin", "ethereum/erc20/wrapped_bitcoin"],
+    metaCurrencyIds: ["bitcoin"],
+  },
+};
+
+// USDC mock data
+const mockPolygonCurrency = {
+  type: "CryptoCurrency" as const,
+  id: "polygon",
+  name: "Polygon",
+  ticker: "MATIC",
+  units: [
+    {
+      name: "MATIC",
+      code: "MATIC",
+      magnitude: 18,
+    },
+  ],
+  family: "evm",
+  managerAppName: "Polygon",
+  coinType: 60,
+  scheme: "polygon",
+  color: "#8247E5",
+  explorerViews: [],
+};
+
+export const mockUsdcAssetsData = {
+  cryptoAssets: {
+    usdc: {
+      id: "usdc",
+      ticker: "USDC",
+      name: "USD Coin",
+      assetsIds: {
+        ethereum: "ethereum/erc20/usd_coin",
+        polygon: "polygon/erc20/usd_coin",
+      },
+    },
+  },
+  networks: {
+    ethereum: { id: "ethereum", name: "Ethereum" },
+    polygon: { id: "polygon", name: "Polygon" },
+  },
+  cryptoOrTokenCurrencies: {
+    "ethereum/erc20/usd_coin": {
+      type: "TokenCurrency" as const,
+      id: "ethereum/erc20/usd_coin",
+      name: "USD Coin",
+      ticker: "USDC",
+      contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      parentCurrency: mockEthereumCurrency,
+      tokenType: "erc20",
+      units: [
+        {
+          name: "USDC",
+          code: "USDC",
+          magnitude: 6,
+        },
+      ],
+    },
+    "polygon/erc20/usd_coin": {
+      type: "TokenCurrency" as const,
+      id: "polygon/erc20/usd_coin",
+      name: "USD Coin (Polygon)",
+      ticker: "USDC",
+      contractAddress: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+      parentCurrency: mockPolygonCurrency,
+      tokenType: "erc20",
+      units: [
+        {
+          name: "USDC",
+          code: "USDC",
+          magnitude: 6,
+        },
+      ],
+    },
+  },
+  interestRates: {},
+  markets: {},
+  currenciesOrder: {
+    key: "marketCap",
+    order: "desc",
+    currenciesIds: ["ethereum/erc20/usd_coin", "polygon/erc20/usd_coin"],
+    metaCurrencyIds: ["usdc"],
+  },
+};

package/src/dada-client/hooks/__tests__/useLazyLedgerCurrency.test.ts

@@ -0,0 +1,155 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { renderHook } from "@testing-library/react";
+import { useLazyLedgerCurrency } from "../useLazyLedgerCurrency";
+import { assetsDataApi } from "../../state-manager/api";
+import useEnv from "../../../hooks/useEnv";
+import {
+  mockAssetsData,
+  mockBitcoinAssetsData,
+  mockUsdcAssetsData,
+} from "../../__mocks__/assets.mock";
+
+jest.mock("../../../hooks/useEnv");
+
+jest.mock("../../state-manager/api", () => ({
+  assetsDataApi: {
+    useLazyGetAssetDataQuery: jest.fn(),
+  },
+}));
+
+const mockUseEnv = jest.mocked(useEnv);
+const mockUseLazyGetAssetDataQuery = jest.mocked(assetsDataApi.useLazyGetAssetDataQuery);
+
+describe("useLazyLedgerCurrency", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockUseEnv.mockReturnValue(false);
+  });
+
+  it("should return undefined when currency is null", async () => {
+    const mockTrigger = jest.fn();
+    mockUseLazyGetAssetDataQuery.mockReturnValue([mockTrigger, {} as any, {} as any]);
+
+    const { result } = renderHook(() =>
+      useLazyLedgerCurrency({ product: "lld", version: "1.0.0" }, null),
+    );
+
+    const ledgerCurrency = await result.current.getLedgerCurrency();
+
+    expect(ledgerCurrency).toBeUndefined();
+    expect(mockTrigger).not.toHaveBeenCalled();
+  });
+
+  it("should return undefined when currency has no ledgerIds", async () => {
+    const mockTrigger = jest.fn();
+    mockUseLazyGetAssetDataQuery.mockReturnValue([mockTrigger, {} as any, {} as any]);
+
+    const currency = { id: "test" };
+    const { result } = renderHook(() =>
+      useLazyLedgerCurrency({ product: "lld", version: "1.0.0" }, currency),
+    );
+
+    const ledgerCurrency = await result.current.getLedgerCurrency();
+
+    expect(ledgerCurrency).toBeUndefined();
+    expect(mockTrigger).not.toHaveBeenCalled();
+  });
+
+  it("should return undefined when currency has empty ledgerIds", async () => {
+    const mockTrigger = jest.fn();
+    mockUseLazyGetAssetDataQuery.mockReturnValue([mockTrigger, {} as any, {} as any]);
+
+    const currency = { id: "test", ledgerIds: [] };
+    const { result } = renderHook(() =>
+      useLazyLedgerCurrency({ product: "lld", version: "1.0.0" }, currency),
+    );
+
+    const ledgerCurrency = await result.current.getLedgerCurrency();
+
+    expect(ledgerCurrency).toBeUndefined();
+    expect(mockTrigger).not.toHaveBeenCalled();
+  });
+
+  it("should return the CryptoCurrency when available (Injective example)", async () => {
+    const mockResult = mockAssetsData;
+
+    const mockTrigger = jest.fn().mockReturnValue({
+      unwrap: jest.fn().mockResolvedValue(mockResult),
+    });
+    mockUseLazyGetAssetDataQuery.mockReturnValue([mockTrigger, {} as any, {} as any]);
+
+    const currency = {
+      id: "injective",
+      ledgerIds: ["injective", "bsc/bep20/injective_protocol", "ethereum/erc20/injective_token"],
+    };
+    const { result } = renderHook(() =>
+      useLazyLedgerCurrency({ product: "lld", version: "1.0.0" }, currency),
+    );
+
+    const ledgerCurrency = await result.current.getLedgerCurrency();
+
+    expect(ledgerCurrency).toMatchObject({
+      type: "CryptoCurrency",
+      id: "injective",
+      name: "Injective",
+      ticker: "INJ",
+    });
+    expect(mockTrigger).toHaveBeenCalledWith(
+      {
+        currencyIds: [
+          "injective",
+          "bsc/bep20/injective_protocol",
+          "ethereum/erc20/injective_token",
+        ],
+        product: "lld",
+        version: "1.0.0",
+        isStaging: false,
+        includeTestNetworks: false,
+      },
+      true,
+    );
+  });
+
+  it("should return the currency matching metaCurrencyId when available", async () => {
+    const mockTrigger = jest.fn().mockReturnValue({
+      unwrap: jest.fn().mockResolvedValue(mockBitcoinAssetsData),
+    });
+    mockUseLazyGetAssetDataQuery.mockReturnValue([mockTrigger, {} as any, {} as any]);
+
+    const currency = { id: "bitcoin", ledgerIds: ["bitcoin"] };
+    const { result } = renderHook(() =>
+      useLazyLedgerCurrency({ product: "lld", version: "1.0.0" }, currency),
+    );
+
+    const ledgerCurrency = await result.current.getLedgerCurrency();
+
+    // Should return the currency matching metaCurrencyId (bitcoin)
+    expect(ledgerCurrency).toMatchObject({
+      type: "CryptoCurrency",
+      id: "bitcoin",
+      name: "Bitcoin",
+      ticker: "BTC",
+    });
+  });
+
+  it("should return first TokenCurrency when no CryptoCurrency available", async () => {
+    const mockTrigger = jest.fn().mockReturnValue({
+      unwrap: jest.fn().mockResolvedValue(mockUsdcAssetsData),
+    });
+    mockUseLazyGetAssetDataQuery.mockReturnValue([mockTrigger, {} as any, {} as any]);
+
+    const currency = { id: "usdc", ledgerIds: ["ethereum/erc20/usd_coin"] };
+    const { result } = renderHook(() =>
+      useLazyLedgerCurrency({ product: "lld", version: "1.0.0" }, currency),
+    );
+
+    const ledgerCurrency = await result.current.getLedgerCurrency();
+
+    // Should return the first TokenCurrency since no CryptoCurrency exists
+    expect(ledgerCurrency?.type).toBe("TokenCurrency");
+    expect(ledgerCurrency?.ticker).toBe("USDC");
+  });
+});

package/src/dada-client/hooks/useAssetsData.ts

@@ -26,8 +26,10 @@ export function useAssetsData({
   version,
   isStaging,
   includeTestNetworks,
+  skip,
 }: GetAssetsDataParams & {
   areCurrenciesFiltered?: boolean;
+  skip?: boolean;
 }) {
   const {
     data,
@@ -39,15 +41,18 @@ export function useAssetsData({
     isFetching,
     isError,
     isFetchingNextPage,
-  } = useGetAssetsDataInfiniteQuery({
-    search,
-    useCase,
-    currencyIds: areCurrenciesFiltered ? currencyIds : undefined,
-    product,
-    version,
-    isStaging,
-    includeTestNetworks,
-  });
+  } = useGetAssetsDataInfiniteQuery(
+    {
+      search,
+      useCase,
+      currencyIds: areCurrenciesFiltered ? currencyIds : undefined,
+      product,
+      version,
+      isStaging,
+      includeTestNetworks,
+    },
+    { skip },
+  );
 
   const joinedPages = useMemo(() => {
     return data?.pages.reduce<AssetsDataWithPagination>((acc, page) => {

package/src/dada-client/hooks/useLazyLedgerCurrency.ts

@@ -0,0 +1,46 @@
+import { useCallback } from "react";
+import { assetsDataApi } from "../state-manager/api";
+import useEnv from "../../hooks/useEnv";
+import { selectCurrency } from "../utils/currencySelection";
+
+interface Currency {
+  id?: string;
+  ledgerIds?: string[];
+}
+
+interface LazyLedgerCurrencyOptions {
+  product: "lld" | "llm";
+  version: string;
+}
+
+export function useLazyLedgerCurrency(
+  options: LazyLedgerCurrencyOptions,
+  currency?: Currency | null,
+) {
+  const devMode = useEnv("MANAGER_DEV_MODE");
+
+  const [triggerGetAssetData] = assetsDataApi.useLazyGetAssetDataQuery();
+
+  const getLedgerCurrency = useCallback(async () => {
+    if (!currency?.ledgerIds || currency.ledgerIds.length === 0) return undefined;
+
+    try {
+      const result = await triggerGetAssetData(
+        {
+          currencyIds: currency.ledgerIds,
+          product: options.product,
+          version: options.version,
+          isStaging: false,
+          includeTestNetworks: devMode,
+        },
+        true, // prefer cached data
+      ).unwrap();
+
+      return selectCurrency(result);
+    } catch {
+      return undefined;
+    }
+  }, [currency, devMode, options, triggerGetAssetData]);
+
+  return { getLedgerCurrency };
+}

package/src/dada-client/index.ts

@@ -0,0 +1 @@
+export * from "./entities";

package/src/dada-client/state-manager/api.ts

@@ -95,7 +95,7 @@ export const assetsDataApi = createApi({
         const baseUrl = queryArg.isStaging ? getEnv("DADA_API_STAGING") : getEnv("DADA_API_PROD");
 
         return {
-          url: `${baseUrl}assets`,
+          url: `${baseUrl}/assets`,
           params,
         };
       },

package/src/dada-client/utils/__test__/currencySelection.test.ts

@@ -0,0 +1,16 @@
+import { selectCurrency } from "../currencySelection";
+import { mockAssetsDataWithPagination } from "../../__mocks__/assets.mock";
+
+describe("currencySelection", () => {
+  it("should return the correct currency", () => {
+    const result = selectCurrency(mockAssetsDataWithPagination);
+    expect(result).toBeDefined();
+
+    expect(result).toMatchObject({
+      type: "CryptoCurrency",
+      id: "injective",
+      name: "Injective",
+      ticker: "INJ",
+    });
+  });
+});

package/src/dada-client/utils/currencySelection.ts

@@ -0,0 +1,33 @@
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { AssetsDataWithPagination } from "../state-manager/types";
+
+/**
+ * Selects the best currency from asset data result based on priority:
+ * 1. Main currency (matching metaCurrencyId)
+ * 2. CryptoCurrency type
+ * 3. First available network
+ */
+export function selectCurrency(
+  result: AssetsDataWithPagination,
+): CryptoOrTokenCurrency | undefined {
+  const metaCurrencyId = result.currenciesOrder.metaCurrencyIds?.[0];
+  if (!metaCurrencyId) return undefined;
+
+  const assetsIds = result.cryptoAssets[metaCurrencyId]?.assetsIds;
+  if (!assetsIds) return undefined;
+
+  let fallback: CryptoOrTokenCurrency | undefined;
+  let crypto: CryptoOrTokenCurrency | undefined;
+
+  for (const id of Object.values(assetsIds)) {
+    const currency = result.cryptoOrTokenCurrencies[id];
+    if (!currency) continue;
+
+    if (currency.id === metaCurrencyId) return currency; // highest priority
+    if (!fallback) fallback = currency;
+    if (!crypto && currency.type === "CryptoCurrency") crypto = currency;
+  }
+
+  // CryptoCurrency > fallback (should be a TokenCurrency)
+  return crypto ?? fallback;
+}

package/src/deposit/deposit.integration.test.ts

@@ -7,6 +7,21 @@ import { useGroupedCurrenciesByProvider } from ".";
 import { GroupedCurrencies, LoadingBasedGroupedCurrencies, MappedAsset } from "./type";
 import * as api from "./api";
 
+// Mock dependencies for useAcceptedCurrency
+jest.mock("../featureFlags", () => ({
+  useFeature: jest.fn().mockReturnValue({ enabled: true }),
+}));
+
+jest.mock("../hooks/useEnv", () => jest.fn().mockReturnValue(false));
+
+// Mock the countervalues API for currenciesByMarketcap
+jest.mock("@ledgerhq/live-countervalues/api/index", () => ({
+  __esModule: true,
+  default: {
+    fetchIdsSortedByMarketcap: jest.fn().mockResolvedValue(["bitcoin", "ethereum"]),
+  },
+}));
+
 // Mock the API module
 jest.mock("./api");
 const mockGetMappedAssets = api.getMappedAssets as jest.MockedFunction<typeof api.getMappedAssets>;