@ledgerhq/cryptoassets 13.32.0-nightly.1 → 13.32.0-nightly.3

package/src/cal-client/entities/index.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+
+/**
+ * Zod schema for token unit
+ */
+export const TokenUnitSchema = z.object({
+  /** Code identifier for the unit */
+  code: z.string(),
+  /** Display name of the unit */
+  name: z.string(),
+  /** Magnitude (number of decimals) */
+  magnitude: z.number(),
+});
+
+export type TokenUnit = z.infer<typeof TokenUnitSchema>;
+
+/**
+ * Zod schema for API token response
+ */
+export const ApiTokenResponseSchema = z.object({
+  /** Type of asset (token or currency) */
+  type: z.string(),
+  /** Unique identifier for the token */
+  id: z.string(),
+  /** Smart contract address */
+  contract_address: z.string(),
+  /** Token standard (e.g., erc20, bep20, spl) */
+  standard: z.string(),
+  /** Number of decimals */
+  decimals: z.number(),
+  /** Network identifier (e.g., arbitrum, ethereum) */
+  network: z.string(),
+  /** Network family (e.g., ethereum, solana) */
+  network_family: z.string(),
+  /** Whether the token is delisted */
+  delisted: z.boolean(),
+  /** Full name of the token */
+  name: z.string(),
+  /** Ticker symbol */
+  ticker: z.string(),
+  /** Array of unit representations */
+  units: z.array(TokenUnitSchema).min(1),
+  /** Symbol */
+  symbol: z.string(),
+  /** Chain ID */
+  chain_id: z.string(),
+  /** Token identifier */
+  token_identifier: z.string().optional(),
+  /** Network type */
+  network_type: z.string(),
+  /** Meta currency ID */
+  meta_currency_id: z.string(),
+  /** Blockchain name */
+  blockchain_name: z.string(),
+  /** Live signature */
+  live_signature: z.string().optional(),
+});
+
+export type ApiTokenResponse = z.infer<typeof ApiTokenResponseSchema>;

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

@@ -0,0 +1,222 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { renderHook } from "@testing-library/react";
+import { useTokensData } from "../useTokensData";
+import { useGetTokensDataInfiniteQuery } from "../../state-manager/api";
+
+jest.mock("../../state-manager/api", () => ({
+  useGetTokensDataInfiniteQuery: jest.fn(),
+}));
+
+const mockUseGetTokensDataInfiniteQuery = jest.mocked(useGetTokensDataInfiniteQuery);
+
+const defaultMockValues = {
+  data: undefined,
+  isLoading: false,
+  error: undefined,
+  fetchNextPage: jest.fn(),
+  isSuccess: true,
+  isFetching: false,
+  isError: false,
+  fetchPreviousPage: jest.fn(),
+  isFetchingPreviousPage: false,
+  refetch: jest.fn(),
+  status: "success",
+};
+
+describe("useAssetsData", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return loading state when API is loading", () => {
+    mockUseGetTokensDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+      isLoading: true,
+      status: "pending",
+    });
+
+    const { result } = renderHook(() =>
+      useTokensData({
+        networkFamily: ["ethereum"],
+        pageSize: 100,
+        output: ["id", "name", "ticker", "contract_address"],
+      }),
+    );
+
+    expect(result.current.isLoading).toBe(true);
+    expect(result.current.data).toBe(undefined);
+  });
+
+  it("should return combined data from multiple pages", () => {
+    const mockPages = [
+      {
+        tokens: [
+          {
+            id: "token-1",
+            name: "Token 1",
+            ticker: "T1",
+            contractAddress: "0x123",
+            parentCurrency: { id: "currency-1", name: "Currency 1" },
+          },
+          {
+            id: "token-2",
+            name: "Token 2",
+            ticker: "T2",
+            contractAddress: "0x456",
+            parentCurrency: { id: "currency-2", name: "Currency 2" },
+          },
+        ],
+        pagination: { nextCursor: "cursor-2" },
+      },
+      {
+        tokens: [
+          {
+            id: "token-3",
+            name: "Token 3",
+            ticker: "T3",
+            contractAddress: "0x789",
+            parentCurrency: { id: "currency-3", name: "Currency 3" },
+          },
+        ],
+        pagination: { nextCursor: undefined },
+      },
+    ];
+
+    mockUseGetTokensDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+      data: { pages: mockPages, pageParams: [{ cursor: "" }, { cursor: "cursor-2" }] },
+    });
+
+    const { result } = renderHook(() =>
+      useTokensData({
+        networkFamily: ["ethereum"],
+        pageSize: 100,
+        output: ["id", "name", "ticker", "contract_address"],
+      }),
+    );
+
+    expect(result.current.data).toEqual({
+      tokens: [
+        {
+          id: "token-1",
+          name: "Token 1",
+          ticker: "T1",
+          contractAddress: "0x123",
+          parentCurrency: { id: "currency-1", name: "Currency 1" },
+        },
+        {
+          id: "token-2",
+          name: "Token 2",
+          ticker: "T2",
+          contractAddress: "0x456",
+          parentCurrency: { id: "currency-2", name: "Currency 2" },
+        },
+        {
+          id: "token-3",
+          name: "Token 3",
+          ticker: "T3",
+          contractAddress: "0x789",
+          parentCurrency: { id: "currency-3", name: "Currency 3" },
+        },
+      ],
+      pagination: { nextCursor: undefined },
+    });
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  it("should return error when API has error", () => {
+    const mockError = new Error("API Error");
+    mockUseGetTokensDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+      data: undefined,
+      error: mockError,
+      isSuccess: false,
+      isError: true,
+      status: "error",
+    });
+
+    const { result } = renderHook(() =>
+      useTokensData({
+        networkFamily: ["ethereum"],
+        pageSize: 100,
+        output: ["id", "name", "ticker", "contract_address"],
+      }),
+    );
+
+    expect(result.current.error).toBe(mockError);
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  it("should provide loadNext function when there's a nextCursor", () => {
+    const mockFetchNextPage = jest.fn();
+    const mockPages = [
+      {
+        tokens: [],
+        pagination: { nextCursor: "next-cursor-456" },
+      },
+    ];
+
+    mockUseGetTokensDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+      data: { pages: mockPages, pageParams: [{ cursor: "" }] },
+      fetchNextPage: mockFetchNextPage,
+    });
+
+    const { result } = renderHook(() =>
+      useTokensData({
+        networkFamily: ["ethereum"],
+        pageSize: 100,
+        output: ["id", "name", "ticker", "contract_address"],
+      }),
+    );
+
+    expect(result.current.loadNext).toBeDefined();
+    result.current.loadNext?.();
+
+    expect(mockFetchNextPage).toHaveBeenCalled();
+  });
+
+  it("should not provide loadNext function when there's no nextCursor", () => {
+    const mockPages = [
+      {
+        tokens: [],
+        pagination: { nextCursor: undefined },
+      },
+    ];
+
+    mockUseGetTokensDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+      data: { pages: mockPages, pageParams: [{ cursor: "" }] },
+    });
+
+    const { result } = renderHook(() =>
+      useTokensData({
+        networkFamily: ["ethereum"],
+        pageSize: 100,
+        output: ["id", "name", "ticker", "contract_address"],
+      }),
+    );
+
+    expect(result.current.loadNext).toBeUndefined();
+  });
+
+  it("should return undefined data when no pages exist", () => {
+    mockUseGetTokensDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+    });
+
+    const { result } = renderHook(() =>
+      useTokensData({
+        networkFamily: ["ethereum"],
+        pageSize: 100,
+        output: ["id", "name", "ticker", "contract_address"],
+      }),
+    );
+
+    expect(result.current.data).toBeUndefined();
+    expect(result.current.loadNext).toBeUndefined();
+  });
+});

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

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

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 { convertApiToken } from "../../api-token-converter";
+
+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 {
+  // convertApiToken handles all format reconciliation internally
+  const result = convertApiToken({
+    id: token.id,
+    contractAddress: token.contract_address,
+    name: token.name,
+    ticker: token.ticker,
+    units: token.units,
+    standard: token.standard,
+    tokenIdentifier: token.token_identifier,
+    delisted: token.delisted,
+    ledgerSignature: token.live_signature,
+  });
+
+  // Add symbol if result exists
+  if (result && token.symbol) {
+    return {
+      ...result,
+      symbol: token.symbol,
+    };
+  }
+
+  return result;
+}
+
+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> = {};