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

package/src/hooks.test.ts

@@ -1,6 +1,6 @@
 import { renderHook, waitFor } from "@testing-library/react";
 import { createCryptoAssetsHooks } from "./hooks";
-import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { TokenCurrency, CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 // Mock the legacy store
 jest.mock("./legacy/legacy-store", () => ({
@@ -10,7 +10,34 @@ jest.mock("./legacy/legacy-store", () => ({
   },
 }));
 
+// 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 = {
@@ -51,6 +78,9 @@ const mockFindTokenByAddressInCurrency =
   legacyCryptoAssetsStore.findTokenByAddressInCurrency as jest.MockedFunction<
     typeof legacyCryptoAssetsStore.findTokenByAddressInCurrency
   >;
+const mockFindCryptoCurrencyById = findCryptoCurrencyById as jest.MockedFunction<
+  typeof findCryptoCurrencyById
+>;
 
 beforeEach(() => {
   jest.clearAllMocks();
@@ -69,6 +99,13 @@ beforeEach(() => {
     }
     return undefined;
   });
+
+  mockFindCryptoCurrencyById.mockImplementation((id: string) => {
+    if (id === "bitcoin") {
+      return mockCryptoCurrency;
+    }
+    return undefined;
+  });
 });
 
 describe("Hooks Factory", () => {
@@ -77,8 +114,10 @@ describe("Hooks Factory", () => {
 
     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", () => {
@@ -275,4 +314,98 @@ describe("Legacy hooks", () => {
       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

@@ -1,6 +1,7 @@
 import { useState, useEffect } from "react";
 import { legacyCryptoAssetsStore } from "./legacy/legacy-store";
-import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { TokenCurrency, CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { findCryptoCurrencyById } from "./currencies";
 
 /**
  * CryptoAssetsHooks is the hooks interface version of the CryptoAssetsStore
@@ -19,6 +20,7 @@ export function createCryptoAssetsHooks(
     return {
       useTokenById: useLegacyTokenById,
       useTokenByAddressInCurrency: useLegacyTokenByAddressInCurrency,
+      useCurrencyById: useLegacyCurrencyById,
     };
   }
 }
@@ -29,9 +31,16 @@ type TokenResult = {
   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 ///////////
@@ -102,3 +111,37 @@ function useLegacyTokenByAddressInCurrency(address: string, currencyId: string)
 
   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/data/exchange/bep20-hash.json

@@ -1 +0,0 @@
-"\"0ebfdae5c996ad89d0f009e300e3a652\""

package/lib/data/exchange/bep20.d.ts

@@ -1,5 +0,0 @@
-export type BEP20Exchange = [string, string, string];
-export { default as hash } from "./bep20-hash.json";
-declare const _default: BEP20Exchange[];
-export default _default;
-//# sourceMappingURL=bep20.d.ts.map

package/lib/data/exchange/bep20.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bep20.d.ts","sourceRoot":"","sources":["../../../src/data/exchange/bep20.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAErD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,mBAAmB,CAAC;;AAIpD,wBAAyC"}

package/lib/data/exchange/bep20.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hash = void 0;
-var bep20_hash_json_1 = require("./bep20-hash.json");
-Object.defineProperty(exports, "hash", { enumerable: true, get: function () { return __importDefault(bep20_hash_json_1).default; } });
-const bep20_json_1 = __importDefault(require("./bep20.json"));
-exports.default = bep20_json_1.default;
-//# sourceMappingURL=bep20.js.map

package/lib/data/exchange/bep20.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bep20.js","sourceRoot":"","sources":["../../../src/data/exchange/bep20.ts"],"names":[],"mappings":";;;;;;AAEA,qDAAoD;AAA3C,wHAAA,OAAO,OAAQ;AAExB,8DAAkC;AAElC,kBAAe,oBAAyB,CAAC"}