@ledgerhq/live-common 34.52.0-nightly.20251105023815 → 34.52.0-nightly.20251106023835

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/families/near/config.ts

@@ -9,6 +9,7 @@ const nearConfig: CurrencyLiveConfigDefinition = {
         API_NEAR_PRIVATE_NODE: "https://near.coin.ledger.com/node",
         API_NEAR_PUBLIC_NODE: "https://rpc.mainnet.near.org",
         API_NEAR_INDEXER: "https://near.coin.ledger.com/indexer",
+        API_NEARBLOCKS_INDEXER: "https://near-indexer.coin.ledger.com",
       },
     },
   },

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";
@@ -25,8 +23,6 @@ import {
   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,

package/src/market/utils/currencyFormatter.ts

@@ -1,4 +1,3 @@
-import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import {
   MarketCurrencyData,
   KeysPriceChange,
@@ -45,29 +44,16 @@ function sparklineAsSvgData(points: number[]): SparklineSvgData {
   };
 }
 
-export function currencyFormatter(
-  data: MarketItemResponse[],
-  cryptoCurrenciesList: (CryptoCurrency | TokenCurrency)[],
-): MarketCurrencyData[] {
-  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)[],
-): MarketCurrencyData => {
-  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/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";
 
@@ -85,7 +84,6 @@ export type MarketCurrencyData = {
   ledgerIds: string[];
   name: string;
   image?: string;
-  internalCurrency?: CryptoOrTokenCurrency;
   marketcap?: number;
   marketcapRank: number;
   totalVolume: number;