@ledgerhq/cryptoassets 13.31.1-nightly.0 → 13.32.0-nightly.2

package/src/cal-client/hooks/useTokensData.ts

@@ -0,0 +1,47 @@
+import { useMemo } from "react";
+import { useGetTokensDataInfiniteQuery } from "../state-manager/api";
+import { TokensDataWithPagination, GetTokensDataParams } from "../state-manager/types";
+
+const emptyData = () => ({
+  tokens: [],
+  pagination: { nextCursor: "" },
+});
+
+export function useTokensData(params: GetTokensDataParams) {
+  const {
+    data,
+    isLoading,
+    error,
+    fetchNextPage,
+    isSuccess,
+    refetch,
+    isFetching,
+    isError,
+    isFetchingNextPage,
+  } = useGetTokensDataInfiniteQuery(params);
+
+  const joinedPages = useMemo(() => {
+    return data?.pages.reduce<TokensDataWithPagination>((acc, page) => {
+      return {
+        tokens: [...acc.tokens, ...page.tokens],
+        pagination: {
+          nextCursor: page.pagination.nextCursor,
+        },
+      };
+    }, emptyData());
+  }, [data]);
+
+  const hasMore = Boolean(joinedPages?.pagination.nextCursor);
+
+  const isInitialLoading = isLoading || (isFetching && !isFetchingNextPage);
+
+  return {
+    data: joinedPages,
+    isLoading: isInitialLoading,
+    error,
+    loadNext: hasMore ? fetchNextPage : undefined,
+    isSuccess,
+    isError,
+    refetch,
+  };
+}

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

@@ -0,0 +1,97 @@
+import { createApi, fetchBaseQuery, FetchBaseQueryMeta } from "@reduxjs/toolkit/query/react";
+import { ApiTokenResponse } from "../entities";
+import { getEnv } from "@ledgerhq/live-env";
+import { GetTokensDataParams, PageParam, TokensDataTags, TokensDataWithPagination } from "./types";
+import { TOKEN_OUTPUT_FIELDS } from "./fields";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { findCryptoCurrencyById } from "../../currencies";
+
+function transformTokensResponse(
+  response: ApiTokenResponse[],
+  meta?: FetchBaseQueryMeta,
+): TokensDataWithPagination {
+  const nextCursor = meta?.response?.headers.get("x-ledger-next") || undefined;
+
+  return {
+    tokens: response.flatMap(token => {
+      const result = transformApiTokenToTokenCurrency(token);
+      return result ? [result] : [];
+    }),
+    pagination: {
+      nextCursor,
+    },
+  };
+}
+
+function transformApiTokenToTokenCurrency(token: ApiTokenResponse): TokenCurrency | undefined {
+  const parentCurrency = findCryptoCurrencyById(token.network);
+  if (!parentCurrency) {
+    return undefined;
+  }
+
+  return {
+    type: "TokenCurrency",
+    id: token.id,
+    ledgerSignature: token.live_signature,
+    contractAddress: token.contract_address,
+    parentCurrency,
+    tokenType: token.standard,
+    name: token.name,
+    ticker: token.ticker,
+    units: token.units.map(unit => ({
+      code: unit.code,
+      name: unit.name,
+      magnitude: unit.magnitude,
+    })),
+    delisted: token.delisted,
+    symbol: token.symbol,
+  };
+}
+
+export const cryptoAssetsApi = createApi({
+  reducerPath: "cryptoAssetsApi",
+  baseQuery: fetchBaseQuery({
+    baseUrl: "",
+  }),
+  tagTypes: [TokensDataTags.Tokens],
+  endpoints: build => ({
+    getTokensData: build.infiniteQuery<TokensDataWithPagination, GetTokensDataParams, PageParam>({
+      query: ({ pageParam, queryArg = {} }) => {
+        const { isStaging = false, output, networkFamily, pageSize = 100, limit, ref } = queryArg;
+
+        const params = {
+          output: output?.join(",") || TOKEN_OUTPUT_FIELDS.join(","),
+          ...(pageParam?.cursor && { cursor: pageParam.cursor }),
+          ...(networkFamily && { network_family: networkFamily }),
+          pageSize,
+          ...(limit && { limit }),
+          ...(ref && { ref }),
+        };
+
+        const baseUrl = isStaging ? getEnv("CAL_SERVICE_URL_STAGING") : getEnv("CAL_SERVICE_URL");
+
+        return {
+          url: `${baseUrl}/v1/tokens`,
+          params,
+        };
+      },
+      providesTags: [TokensDataTags.Tokens],
+      transformResponse: transformTokensResponse,
+      infiniteQueryOptions: {
+        initialPageParam: {
+          cursor: "",
+        },
+        getNextPageParam: lastPage => {
+          if (lastPage.pagination.nextCursor) {
+            return {
+              cursor: lastPage.pagination.nextCursor,
+            };
+          }
+          return undefined;
+        },
+      },
+    }),
+  }),
+});
+
+export const { useGetTokensDataInfiniteQuery } = cryptoAssetsApi;

package/src/cal-client/state-manager/fields.ts

@@ -0,0 +1,20 @@
+export const TOKEN_OUTPUT_FIELDS = [
+  "id",
+  "name",
+  "ticker",
+  "symbol",
+  "contract_address",
+  "standard",
+  "decimals",
+  "network",
+  "network_family",
+  "units",
+  "type",
+  "delisted",
+  "chain_id",
+  "token_identifier",
+  "network_type",
+  "meta_currency_id",
+  "blockchain_name",
+  "live_signature",
+] as const;

package/src/cal-client/state-manager/types.ts

@@ -0,0 +1,39 @@
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+export enum TokensDataTags {
+  Tokens = "Tokens",
+}
+
+/**
+ * Parameters for the getTokensData query
+ *
+ * @param networkFamily - Filter by network families (e.g., ["ethereum", "polygon"])
+ * @param isStaging - Use staging or production environment
+ * @param pageSize - Number of items per page (default: 100, options: 10, 100, 1000)
+ * @param output - Specify output fields (default: all fields, values: id, name, ticker, units, delisted)
+ * @param limit - Maximum number of assets to return
+ * @param ref - Reference to the source of the data Default: "branch:main"  Examples:
+ *   - ref=branch:main - Main branch HEAD
+ *   - ref=tag:tokens-1.11.12 - specific tag
+ *   - ref=commit:48188c6ca2888a9c50a0466d2442ec2f24cc2852 - specific commit
+ *   - CAL reference to use
+ */
+export interface GetTokensDataParams {
+  networkFamily?: string[];
+  output?: string[];
+  limit?: number;
+  pageSize?: number;
+  ref?: string;
+  isStaging?: boolean;
+}
+
+export interface PageParam {
+  cursor?: string;
+}
+
+export interface TokensDataWithPagination {
+  tokens: TokenCurrency[];
+  pagination: {
+    nextCursor?: string;
+  };
+}

package/src/currencies.ts

@@ -3487,6 +3487,37 @@ export const cryptocurrenciesById: Record<CryptoCurrencyId, CryptoCurrency> = {
     ],
     explorerId: "btc_testnet",
   },
+  bitcoin_regtest: {
+    type: "CryptoCurrency",
+    id: "bitcoin_regtest",
+    coinType: CoinType.BTC_TESTNET,
+    name: "Bitcoin Regtest",
+    managerAppName: "Bitcoin Test",
+    ticker: "BTC",
+    scheme: "regtest",
+    color: "#00ff00",
+    symbol: "Ƀ",
+    units: bitcoinUnits.map(makeTestnetUnit),
+    deviceTicker: "TEST",
+    supportsSegwit: true,
+    supportsNativeSegwit: true,
+    isTestnetFor: "bitcoin",
+    disableCountervalue: true,
+    family: "bitcoin",
+    blockAvgTime: 15 * 60,
+    bitcoinLikeInfo: {
+      P2PKH: 111,
+      P2SH: 196,
+      XPUBVersion: 0x043587cf,
+    },
+    explorerViews: [
+      {
+        tx: "https://live.blockcypher.com/btc-testnet/tx/$hash",
+        address: "https://live.blockcypher.com/btc-testnet/address/$address",
+      },
+    ],
+    explorerId: "btc_testnet",
+  },
   ethereum_sepolia: {
     type: "CryptoCurrency",
     id: "ethereum_sepolia",
@@ -4788,6 +4819,27 @@ export const cryptocurrenciesById: Record<CryptoCurrencyId, CryptoCurrency> = {
       },
     ],
   },
+  monad: {
+    type: "CryptoCurrency",
+    id: "monad",
+    coinType: CoinType.ETH,
+    name: "Monad",
+    managerAppName: "Ethereum",
+    ticker: "MON",
+    scheme: "monad",
+    color: "#836EF9",
+    family: "evm",
+    units: ethereumUnits("MON", "MON"),
+    ethereumLikeInfo: {
+      chainId: 143,
+    },
+    explorerViews: [
+      {
+        tx: "https://monadexplorer.com/tx/$hash",
+        address: "https://monadexplorer.com/address/$address",
+      },
+    ],
+  },
 };
 
 const cryptocurrenciesByScheme: Record<string, CryptoCurrency> = {};

package/src/legacy/legacy-store.ts

@@ -1,6 +1,6 @@
 import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
-import { tokensById, tokensByCurrencyAddress } from "./legacy-state";
+import { tokensById, tokensByCurrencyAddress, tokensByCryptoCurrency } from "./legacy-state";
 
 function findTokenById(id: string): TokenCurrency | undefined {
   return tokensById[id];
@@ -13,6 +13,11 @@ function findTokenByAddressInCurrency(
   return tokensByCurrencyAddress[currencyId + ":" + address.toLowerCase()];
 }
 
+function getTokensSyncHash(currencyId: string): Promise<string> {
+  const tokens = tokensByCryptoCurrency[currencyId];
+  return Promise.resolve("legacy_" + tokens?.length);
+}
+
 /**
  * Legacy CryptoAssetsStore adapter that wraps the legacy token lookup functions
  * and provides the CryptoAssetsStore interface expected by the rest of the codebase.
@@ -20,4 +25,5 @@ function findTokenByAddressInCurrency(
 export const legacyCryptoAssetsStore: CryptoAssetsStore = {
   findTokenById,
   findTokenByAddressInCurrency,
+  getTokensSyncHash,
 };

package/src/legacy/legacy.test.ts

@@ -30,6 +30,7 @@ import {
   tokensByCurrencyAddress,
   tokenListHashes,
 } from "./legacy-state";
+import { legacyCryptoAssetsStore } from "./legacy-store";
 import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type {
   ERC20Token,
@@ -567,6 +568,98 @@ describe("Legacy Data", () => {
   });
 });
 
+describe("legacyCryptoAssetsStore", () => {
+  beforeEach(() => {
+    __clearAllLists();
+  });
+
+  it("should find token by id", () => {
+    const erc20Token: ERC20Token = [
+      "ethereum",
+      "test_token",
+      "TEST",
+      18,
+      "Test Token",
+      "signature",
+      "0x123",
+      false,
+      false,
+    ];
+
+    addTokens([convertERC20(erc20Token)].filter(Boolean) as TokenCurrency[]);
+
+    const token = legacyCryptoAssetsStore.findTokenById("ethereum/erc20/test_token");
+
+    expect(token).toMatchObject({ ticker: "TEST" });
+  });
+
+  it("should find token by address in currency", () => {
+    const erc20Token: ERC20Token = [
+      "ethereum",
+      "test_token",
+      "TEST",
+      18,
+      "Test Token",
+      "signature",
+      "0xABC123",
+      false,
+      false,
+    ];
+
+    addTokens([convertERC20(erc20Token)].filter(Boolean) as TokenCurrency[]);
+
+    const token = legacyCryptoAssetsStore.findTokenByAddressInCurrency("0xabc123", "ethereum");
+
+    expect(token).toMatchObject({ ticker: "TEST" });
+  });
+
+  it("should return undefined for non-existent token by address", () => {
+    const token = legacyCryptoAssetsStore.findTokenByAddressInCurrency("0xnonexistent", "ethereum");
+
+    expect(token).toBeUndefined();
+  });
+
+  it("should return sync hash for currency with tokens", async () => {
+    const erc20Token1: ERC20Token = [
+      "ethereum",
+      "test_token1",
+      "TEST1",
+      18,
+      "Test Token 1",
+      "signature1",
+      "0x123",
+      false,
+      false,
+    ];
+
+    const erc20Token2: ERC20Token = [
+      "ethereum",
+      "test_token2",
+      "TEST2",
+      18,
+      "Test Token 2",
+      "signature2",
+      "0x456",
+      false,
+      false,
+    ];
+
+    addTokens(
+      [convertERC20(erc20Token1), convertERC20(erc20Token2)].filter(Boolean) as TokenCurrency[],
+    );
+
+    const hash = await legacyCryptoAssetsStore.getTokensSyncHash("ethereum");
+
+    expect(hash).toBe("legacy_2");
+  });
+
+  it("should return sync hash for currency with no tokens", async () => {
+    const hash = await legacyCryptoAssetsStore.getTokensSyncHash("bitcoin");
+
+    expect(hash).toBe("legacy_undefined");
+  });
+});
+
 describe("Legacy State", () => {
   it("should export all state objects", () => {
     expect(tokensArray).toBeDefined();