@ledgerhq/cryptoassets 13.31.0-nightly.6 → 13.31.0-nightly.8

package/src/api-asset-converter.test.ts

@@ -29,7 +29,7 @@ describe("convertApiAsset", () => {
       expect(result?.ticker).toBe("BTC");
     });
 
-    it("should return undefined for unknown crypto currency", () => {
+    it("should create dynamic crypto currency for unknown crypto currency", () => {
       const apiCrypto: ApiCryptoCurrency = {
         type: "crypto_currency",
         id: "nonexistent_coin",
@@ -40,7 +40,20 @@ describe("convertApiAsset", () => {
 
       const result = convertApiAsset(apiCrypto);
 
-      expect(result).toBeUndefined();
+      expect(result).toBeDefined();
+      expect(result?.type).toBe("CryptoCurrency");
+      expect(result?.id).toBe("nonexistent_coin");
+      expect(result?.name).toBe("Nonexistent Coin");
+      expect(result?.ticker).toBe("NONE");
+      // Check default/placeholder values
+      if (result?.type === "CryptoCurrency") {
+        expect(result.managerAppName).toBe("Nonexistent Coin");
+        expect(result.coinType).toBe(0);
+        expect(result.scheme).toBe("nonexistent_coin");
+        expect(result.color).toBe("#999999");
+        expect(result.family).toBe("nonexistent_coin");
+        expect(result.explorerViews).toEqual([]);
+      }
     });
 
     it("should handle crypto currency with all optional fields", () => {
@@ -193,7 +206,7 @@ describe("convertApiAssets", () => {
     expect(result.eth?.id).toBe("ethereum");
   });
 
-  it("should skip assets that fail conversion", () => {
+  it("should convert known crypto and create dynamic crypto, but skip unsupported tokens", () => {
     const apiAssets: Record<string, ApiAsset> = {
       valid: {
         type: "crypto_currency",
@@ -222,9 +235,13 @@ describe("convertApiAssets", () => {
 
     const result = convertApiAssets(apiAssets);
 
-    expect(Object.keys(result)).toHaveLength(1);
+    // Now converts both known and unknown cryptocurrencies, but skips unsupported tokens
+    expect(Object.keys(result)).toHaveLength(2);
     expect(result.valid).toBeDefined();
-    expect(result.invalid_crypto).toBeUndefined();
+    expect(result.valid?.id).toBe("bitcoin");
+    expect(result.invalid_crypto).toBeDefined();
+    expect(result.invalid_crypto?.type).toBe("CryptoCurrency");
+    expect(result.invalid_crypto?.id).toBe("nonexistent");
     expect(result.invalid_token).toBeUndefined();
   });
 

package/src/api-asset-converter.ts

@@ -47,7 +47,38 @@ export function convertApiAsset(apiAsset: ApiAsset): CryptoOrTokenCurrency | und
 }
 
 function convertApiCryptoCurrency(apiCrypto: ApiCryptoCurrency): CryptoOrTokenCurrency | undefined {
-  return findCryptoCurrencyById(apiCrypto.id);
+  const localCrypto = findCryptoCurrencyById(apiCrypto.id);
+  if (localCrypto) {
+    return localCrypto;
+  }
+
+  // Create a dynamic CryptoCurrency object with placeholders for fields we can't infer
+  return {
+    type: "CryptoCurrency" as const,
+    id: apiCrypto.id,
+    name: apiCrypto.name,
+    ticker: apiCrypto.ticker,
+    units: apiCrypto.units.map(unit => ({
+      name: unit.name,
+      code: unit.code,
+      magnitude: unit.magnitude,
+    })),
+    // Required fields with placeholders when not available in API
+    managerAppName: apiCrypto.name, // Placeholder: use name as fallback
+    coinType: apiCrypto.coinType ?? 0, // Placeholder: default to 0 if not provided
+    scheme: apiCrypto.id.toLowerCase(), // Placeholder: use lowercase ticker
+    color: "#999999", // Placeholder: default gray color
+    family: apiCrypto.family ?? apiCrypto.id, // Placeholder: default to "unknown" if not provided
+    explorerViews: [], // Placeholder: empty array
+    // Optional fields from API
+    symbol: apiCrypto.symbol,
+    disableCountervalue: apiCrypto.disableCountervalue,
+    supportsSegwit: apiCrypto.hasSegwit,
+    // Add ethereumLikeInfo if chainId is present
+    ...(apiCrypto.chainId && {
+      ethereumLikeInfo: { chainId: parseInt(apiCrypto.chainId, 10) },
+    }),
+  };
 }
 
 function convertApiTokenCurrency(apiToken: ApiTokenCurrency): CryptoOrTokenCurrency | undefined {

package/src/hooks.test.ts

@@ -0,0 +1,411 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { createCryptoAssetsHooks } from "./hooks";
+import type { TokenCurrency, CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+// Mock the legacy store
+jest.mock("./legacy/legacy-store", () => ({
+  legacyCryptoAssetsStore: {
+    findTokenById: jest.fn(),
+    findTokenByAddressInCurrency: jest.fn(),
+  },
+}));
+
+// Mock the currencies module
+jest.mock("./currencies", () => ({
+  findCryptoCurrencyById: jest.fn(),
+}));
+
+import { legacyCryptoAssetsStore } from "./legacy/legacy-store";
+import { findCryptoCurrencyById } from "./currencies";
+
+// Mock crypto currency data
+const mockCryptoCurrency: CryptoCurrency = {
+  type: "CryptoCurrency",
+  id: "bitcoin",
+  name: "Bitcoin",
+  ticker: "BTC",
+  units: [
+    {
+      code: "BTC",
+      name: "Bitcoin",
+      magnitude: 8,
+    },
+  ],
+  family: "bitcoin",
+  managerAppName: "Bitcoin",
+  coinType: 0,
+  scheme: "bitcoin",
+  color: "#FF9900",
+  explorerViews: [],
+};
+
+// Mock token data
+const mockToken: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/usd_coin",
+  ledgerSignature: "3045022100...",
+  contractAddress: "0xA0b86a33E6441b8c4C8C0e4b8b8c4C8C0e4b8b8c4",
+  parentCurrency: {
+    type: "CryptoCurrency",
+    id: "ethereum",
+    name: "Ethereum",
+    ticker: "ETH",
+    units: [],
+    family: "ethereum",
+    managerAppName: "Ethereum",
+    coinType: 60,
+    scheme: "ethereum",
+    color: "#627EEA",
+    explorerViews: [],
+  },
+  tokenType: "erc20",
+  name: "USD Coin",
+  ticker: "USDC",
+  units: [
+    {
+      code: "USDC",
+      name: "USD Coin",
+      magnitude: 6,
+    },
+  ],
+};
+
+// Setup mock implementations
+const mockFindTokenById = legacyCryptoAssetsStore.findTokenById as jest.MockedFunction<
+  typeof legacyCryptoAssetsStore.findTokenById
+>;
+const mockFindTokenByAddressInCurrency =
+  legacyCryptoAssetsStore.findTokenByAddressInCurrency as jest.MockedFunction<
+    typeof legacyCryptoAssetsStore.findTokenByAddressInCurrency
+  >;
+const mockFindCryptoCurrencyById = findCryptoCurrencyById as jest.MockedFunction<
+  typeof findCryptoCurrencyById
+>;
+
+beforeEach(() => {
+  jest.clearAllMocks();
+
+  // Default mock implementations
+  mockFindTokenById.mockImplementation((id: string) => {
+    if (id === "ethereum/erc20/usd_coin") {
+      return mockToken;
+    }
+    return undefined;
+  });
+
+  mockFindTokenByAddressInCurrency.mockImplementation((address: string, currencyId: string) => {
+    if (address === "0xA0b86a33E6441b8c4C8C0e4b8b8c4C8C0e4b8b8c4" && currencyId === "ethereum") {
+      return mockToken;
+    }
+    return undefined;
+  });
+
+  mockFindCryptoCurrencyById.mockImplementation((id: string) => {
+    if (id === "bitcoin") {
+      return mockCryptoCurrency;
+    }
+    return undefined;
+  });
+});
+
+describe("Hooks Factory", () => {
+  it("should return legacy hooks when useCALBackend is false", () => {
+    const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+
+    expect(hooks.useTokenById).toBeDefined();
+    expect(hooks.useTokenByAddressInCurrency).toBeDefined();
+    expect(hooks.useCurrencyById).toBeDefined();
+    expect(hooks.useTokenById).toBeInstanceOf(Function);
+    expect(hooks.useTokenByAddressInCurrency).toBeInstanceOf(Function);
+    expect(hooks.useCurrencyById).toBeInstanceOf(Function);
+  });
+
+  it("should throw an error when useCALBackend is true", () => {
+    // @ts-expect-error useCALBackend is not supported yet
+    expect(() => createCryptoAssetsHooks({ useCALBackend: true })).toThrow();
+  });
+});
+
+describe("Legacy hooks", () => {
+  describe("useTokenById", () => {
+    it("should start with loading state and then return token", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() => hooks.useTokenById("ethereum/erc20/usd_coin"));
+
+      // Initial loading state
+      expect(result.current.loading).toBe(true);
+      expect(result.current.token).toBeUndefined();
+      expect(result.current.error).toBeUndefined();
+
+      // Wait for the async operation to complete
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Settled state with token
+      expect(result.current.token).toBe(mockToken);
+      expect(result.current.error).toBeUndefined();
+    });
+
+    it("should handle empty id parameter", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() => hooks.useTokenById(""));
+
+      // Should immediately settle with no token
+      expect(result.current.loading).toBe(false);
+      expect(result.current.token).toBeUndefined();
+      expect(result.current.error).toBeUndefined();
+    });
+
+    it("should handle non-existent token id", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() => hooks.useTokenById("non-existent-token"));
+
+      // Initial loading state
+      expect(result.current.loading).toBe(true);
+
+      // Wait for the async operation to complete
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Settled state with no token (but no error since the store returns undefined)
+      expect(result.current.token).toBeUndefined();
+      expect(result.current.error).toBeUndefined();
+    });
+
+    it("should re-run when id changes", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result, rerender } = renderHook(({ id }) => hooks.useTokenById(id), {
+        initialProps: { id: "ethereum/erc20/usd_coin" },
+      });
+
+      // Wait for first token to load
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+        expect(result.current.token).toBe(mockToken);
+      });
+
+      // Change the id
+      rerender({ id: "different-token" });
+
+      // Should start loading again and reset token
+      expect(result.current.loading).toBe(true);
+
+      // Wait for the token to be reset
+      await waitFor(() => {
+        expect(result.current.token).toBeUndefined();
+      });
+
+      // Wait for new search to complete
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Should have no token for the new id
+      expect(result.current.token).toBeUndefined();
+    });
+  });
+
+  describe("useTokenByAddressInCurrency", () => {
+    it("should start with loading state and then return token", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() =>
+        hooks.useTokenByAddressInCurrency(
+          "0xA0b86a33E6441b8c4C8C0e4b8b8c4C8C0e4b8b8c4",
+          "ethereum",
+        ),
+      );
+
+      // Initial loading state
+      expect(result.current.loading).toBe(true);
+      expect(result.current.token).toBeUndefined();
+      expect(result.current.error).toBeUndefined();
+
+      // Wait for the async operation to complete
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Settled state with token
+      expect(result.current.token).toBe(mockToken);
+      expect(result.current.error).toBeUndefined();
+    });
+
+    it("should handle empty address parameter", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() => hooks.useTokenByAddressInCurrency("", "ethereum"));
+
+      // Should immediately settle with no token
+      expect(result.current.loading).toBe(false);
+      expect(result.current.token).toBeUndefined();
+      expect(result.current.error).toBeUndefined();
+    });
+
+    it("should handle empty currencyId parameter", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() =>
+        hooks.useTokenByAddressInCurrency("0xA0b86a33E6441b8c4C8C0e4b8b8c4C8C0e4b8b8c4", ""),
+      );
+
+      // Should immediately settle with no token
+      expect(result.current.loading).toBe(false);
+      expect(result.current.token).toBeUndefined();
+      expect(result.current.error).toBeUndefined();
+    });
+
+    it("should handle non-existent token address", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() =>
+        hooks.useTokenByAddressInCurrency("0xNonExistentAddress", "ethereum"),
+      );
+
+      // Initial loading state
+      expect(result.current.loading).toBe(true);
+
+      // Wait for the async operation to complete
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Settled state with no token (but no error since the store returns undefined)
+      expect(result.current.token).toBeUndefined();
+      expect(result.current.error).toBeUndefined();
+    });
+
+    it("should re-run when address or currencyId changes", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result, rerender } = renderHook(
+        ({ address, currencyId }) => hooks.useTokenByAddressInCurrency(address, currencyId),
+        {
+          initialProps: {
+            address: "0xA0b86a33E6441b8c4C8C0e4b8b8c4C8C0e4b8b8c4",
+            currencyId: "ethereum",
+          },
+        },
+      );
+
+      // Wait for first token to load
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+        expect(result.current.token).toBe(mockToken);
+      });
+
+      // Change the address
+      rerender({
+        address: "0xDifferentAddress",
+        currencyId: "ethereum",
+      });
+
+      // Should start loading again and reset token
+      expect(result.current.loading).toBe(true);
+
+      // Wait for the token to be reset
+      await waitFor(() => {
+        expect(result.current.token).toBeUndefined();
+      });
+
+      // Wait for new search to complete
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Should have no token for the new address
+      expect(result.current.token).toBeUndefined();
+    });
+  });
+
+  describe("useCurrencyById", () => {
+    it("should return crypto currency when found", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() => hooks.useCurrencyById("bitcoin"));
+
+      // Initial loading state
+      expect(result.current.loading).toBe(true);
+      expect(result.current.currency).toBeUndefined();
+      expect(result.current.error).toBeUndefined();
+
+      // Wait for the async operation to complete
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Settled state with crypto currency
+      expect(result.current.currency).toBe(mockCryptoCurrency);
+      expect(result.current.error).toBeUndefined();
+    });
+
+    it("should fallback to token when crypto currency not found", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() => hooks.useCurrencyById("ethereum/erc20/usd_coin"));
+
+      // Initial loading state
+      expect(result.current.loading).toBe(true);
+
+      // Wait for the async operation to complete
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Settled state with token
+      expect(result.current.currency).toBe(mockToken);
+      expect(result.current.error).toBeUndefined();
+      expect(mockFindCryptoCurrencyById).toHaveBeenCalledWith("ethereum/erc20/usd_coin");
+      expect(mockFindTokenById).toHaveBeenCalledWith("ethereum/erc20/usd_coin");
+    });
+
+    it("should handle empty id parameter", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() => hooks.useCurrencyById(""));
+
+      // Should immediately settle with no currency
+      expect(result.current.loading).toBe(false);
+      expect(result.current.currency).toBeUndefined();
+      expect(result.current.error).toBeUndefined();
+    });
+
+    it("should handle non-existent currency id", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result } = renderHook(() => hooks.useCurrencyById("non-existent"));
+
+      // Initial loading state
+      expect(result.current.loading).toBe(true);
+
+      // Wait for the async operation to complete
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Settled state with no currency
+      expect(result.current.currency).toBeUndefined();
+      expect(result.current.error).toBeUndefined();
+    });
+
+    it("should re-run when id changes", async () => {
+      const hooks = createCryptoAssetsHooks({ useCALBackend: false });
+      const { result, rerender } = renderHook(({ id }) => hooks.useCurrencyById(id), {
+        initialProps: { id: "bitcoin" },
+      });
+
+      // Wait for first currency to load
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+        expect(result.current.currency).toBe(mockCryptoCurrency);
+      });
+
+      // Change the id to a token
+      rerender({ id: "ethereum/erc20/usd_coin" });
+
+      // Should start loading again
+      expect(result.current.loading).toBe(true);
+
+      // Wait for new search to complete
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Should have token for the new id
+      expect(result.current.currency).toBe(mockToken);
+    });
+  });
+});

package/src/hooks.ts

@@ -0,0 +1,147 @@
+import { useState, useEffect } from "react";
+import { legacyCryptoAssetsStore } from "./legacy/legacy-store";
+import type { TokenCurrency, CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { findCryptoCurrencyById } from "./currencies";
+
+/**
+ * CryptoAssetsHooks is the hooks interface version of the CryptoAssetsStore
+ * This work provide a common interface for the hooks, and the backend implementation will be completed in the future
+ * See https://github.com/LedgerHQ/ledger-live/pull/11951
+ */
+export function createCryptoAssetsHooks(
+  config: {
+    useCALBackend?: false; // at the moment, we only support legacy
+    api?: unknown; // placeholder for the future
+  } = {},
+): Hooks {
+  if (config.useCALBackend) {
+    throw new Error("backend is not supported yet");
+  } else {
+    return {
+      useTokenById: useLegacyTokenById,
+      useTokenByAddressInCurrency: useLegacyTokenByAddressInCurrency,
+      useCurrencyById: useLegacyCurrencyById,
+    };
+  }
+}
+
+type TokenResult = {
+  token: TokenCurrency | undefined;
+  loading: boolean;
+  error: unknown;
+};
+
+type CurrencyResult = {
+  currency: CryptoCurrency | TokenCurrency | undefined;
+  loading: boolean;
+  error: unknown;
+};
+
+type Hooks = {
+  useTokenById: (id: string) => TokenResult;
+  useTokenByAddressInCurrency: (address: string, currencyId: string) => TokenResult;
+  useCurrencyById: (id: string) => CurrencyResult;
+};
+
+/////////// Legacy hooks using legacyCryptoAssetsStore ///////////
+
+function useLegacyTokenById(id: string) {
+  const [token, setToken] = useState<TokenCurrency | undefined>(undefined);
+  const [loading, setLoading] = useState<boolean>(true);
+  const [error, setError] = useState<unknown>(undefined);
+
+  useEffect(() => {
+    if (!id) {
+      setToken(undefined);
+      setLoading(false);
+      return;
+    }
+
+    const fetchToken = async () => {
+      try {
+        setLoading(true);
+        setError(undefined);
+        const result = await legacyCryptoAssetsStore.findTokenById(id);
+        setToken(result);
+      } catch (err) {
+        setError(err);
+        setToken(undefined);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchToken();
+  }, [id]);
+
+  return { token, loading, error };
+}
+
+function useLegacyTokenByAddressInCurrency(address: string, currencyId: string) {
+  const [token, setToken] = useState<TokenCurrency | undefined>(undefined);
+  const [loading, setLoading] = useState<boolean>(true);
+  const [error, setError] = useState<unknown>(undefined);
+
+  useEffect(() => {
+    if (!address || !currencyId) {
+      setToken(undefined);
+      setLoading(false);
+      return;
+    }
+
+    const fetchToken = async () => {
+      try {
+        setLoading(true);
+        setError(undefined);
+        const result = await legacyCryptoAssetsStore.findTokenByAddressInCurrency(
+          address,
+          currencyId,
+        );
+        setToken(result);
+      } catch (err) {
+        setError(err);
+        setToken(undefined);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchToken();
+  }, [address, currencyId]);
+
+  return { token, loading, error };
+}
+
+function useLegacyCurrencyById(id: string) {
+  const [currency, setCurrency] = useState<CryptoCurrency | TokenCurrency | undefined>(undefined);
+  const [loading, setLoading] = useState<boolean>(true);
+  const [error, setError] = useState<unknown>(undefined);
+
+  useEffect(() => {
+    if (!id) {
+      setCurrency(undefined);
+      setLoading(false);
+      return;
+    }
+
+    const fetchCurrency = async () => {
+      try {
+        setLoading(true);
+        setError(undefined);
+        // First try to find as a crypto currency
+        const cryptoCurrency = await Promise.resolve(findCryptoCurrencyById(id));
+        const result = cryptoCurrency || (await legacyCryptoAssetsStore.findTokenById(id));
+        setCurrency(result);
+      } catch (err) {
+        setError(err);
+        setCurrency(undefined);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchCurrency();
+  }, [id]);
+
+  return { currency, loading, error };
+}

package/src/index.ts

@@ -3,6 +3,5 @@ export * from "./currencies";
 export * from "./tokens";
 export * from "./api-token-converter";
 export * from "./api-asset-converter";
-export * from "./exchange";
 export * from "./abandonseed";
 export * from "./types";

package/lib/api-asset-converter.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=api-asset-converter.test.d.ts.map

package/lib/api-asset-converter.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-asset-converter.test.d.ts","sourceRoot":"","sources":["../src/api-asset-converter.test.ts"],"names":[],"mappings":""}