@ledgerhq/live-common 34.38.1 → 34.38.2-nightly.0

package/lib-es/bridge/cache.js

@@ -11,14 +11,14 @@ export function makeBridgeCacheSystem({ saveData, getData, }) {
         return value;
     };
     const lruCaches = {};
-    const prepareCurrency = async (currency) => {
+    const prepareCurrency = async (currency, { forceUpdate } = { forceUpdate: false }) => {
         const bridge = getCurrencyBridge(currency);
         const { preloadMaxAge } = {
             ...defaultCacheStrategy,
             ...(bridge.getPreloadStrategy && bridge.getPreloadStrategy(currency)),
         };
         let cache = lruCaches[currency.id];
-        if (!cache) {
+        if (!cache || forceUpdate) {
             cache = makeLRUCache(async () => {
                 const preloaded = await bridge.preload(currency);
                 if (preloaded) {

package/lib-es/bridge/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/bridge/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAG5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,IAAI,CAAC;AAEvC,MAAM,oBAAoB,GAAG;IAC3B,aAAa,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI;CAC7B,CAAC;AACF,MAAM,UAAU,qBAAqB,CAAC,EACpC,QAAQ,EACR,OAAO,GAIR;IACC,MAAM,eAAe,GAAG,KAAK,EAAE,QAAwB,EAAE,EAAE;QACzD,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtC,MAAM,MAAM,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAC3C,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAChC,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,MAAM,SAAS,GAAG,EAAE,CAAC;IAErB,MAAM,eAAe,GAAG,KAAK,EAAE,QAAwB,EAAE,EAAE;QACzD,MAAM,MAAM,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAC3C,MAAM,EAAE,aAAa,EAAE,GAAG;YACxB,GAAG,oBAAoB;YACvB,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,MAAM,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;SACtE,CAAC;QACF,IAAI,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAEnC,IAAI,CAAC,KAAK,EAAE;YACV,KAAK,GAAG,YAAY,CAClB,KAAK,IAAI,EAAE;gBACT,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAEjD,IAAI,SAAS,EAAE;oBACb,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;oBACpC,MAAM,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;iBACrC;gBAED,OAAO,SAAS,CAAC;YACnB,CAAC,EACD,GAAG,EAAE,CAAC,EAAE,EACR;gBACE,GAAG,EAAE,aAAa;aACnB,CACF,CAAC;YACF,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC;SAChC;QAED,OAAO,KAAK,EAAE,CAAC;IACjB,CAAC,CAAC;IAEF,OAAO;QACL,eAAe;QACf,eAAe;KAChB,CAAC;AACJ,CAAC"}
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/bridge/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAG5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,IAAI,CAAC;AAEvC,MAAM,oBAAoB,GAAG;IAC3B,aAAa,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI;CAC7B,CAAC;AACF,MAAM,UAAU,qBAAqB,CAAC,EACpC,QAAQ,EACR,OAAO,GAIR;IACC,MAAM,eAAe,GAAG,KAAK,EAAE,QAAwB,EAAE,EAAE;QACzD,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtC,MAAM,MAAM,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAC3C,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAChC,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,MAAM,SAAS,GAAG,EAAE,CAAC;IAErB,MAAM,eAAe,GAAG,KAAK,EAC3B,QAAwB,EACxB,EAAE,WAAW,KAA+B,EAAE,WAAW,EAAE,KAAK,EAAE,EAClE,EAAE;QACF,MAAM,MAAM,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAC3C,MAAM,EAAE,aAAa,EAAE,GAAG;YACxB,GAAG,oBAAoB;YACvB,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,MAAM,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;SACtE,CAAC;QACF,IAAI,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAEnC,IAAI,CAAC,KAAK,IAAI,WAAW,EAAE;YACzB,KAAK,GAAG,YAAY,CAClB,KAAK,IAAI,EAAE;gBACT,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAEjD,IAAI,SAAS,EAAE;oBACb,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;oBACpC,MAAM,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;iBACrC;gBAED,OAAO,SAAS,CAAC;YACnB,CAAC,EACD,GAAG,EAAE,CAAC,EAAE,EACR;gBACE,GAAG,EAAE,aAAa;aACnB,CACF,CAAC;YACF,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC;SAChC;QAED,OAAO,KAAK,EAAE,CAAC;IACjB,CAAC,CAAC;IAEF,OAAO;QACL,eAAe;QACf,eAAe;KAChB,CAAC;AACJ,CAAC"}

package/lib-es/bridge/cache.test.d.ts

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

package/lib-es/bridge/cache.test.d.ts.map

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

package/lib-es/bridge/cache.test.js

@@ -0,0 +1,38 @@
+import * as cacheModule from "@ledgerhq/live-network/cache";
+import { makeBridgeCacheSystem } from "./cache";
+import { getCryptoCurrencyById } from "../currencies";
+import { setEnv } from "@ledgerhq/live-env";
+describe("Bridge Cache", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    beforeAll(() => {
+        setEnv("MOCK", "1");
+    });
+    afterAll(() => {
+        setEnv("MOCK", "");
+    });
+    it("does not re-generate the LRU cache by default", async () => {
+        const makeLRUCache = jest.spyOn(cacheModule, "makeLRUCache");
+        const { prepareCurrency } = makeBridgeCacheSystem({
+            saveData: () => Promise.resolve(),
+            getData: () => Promise.resolve(null),
+        });
+        await prepareCurrency(getCryptoCurrencyById("solana"));
+        expect(makeLRUCache).toHaveBeenCalledTimes(1);
+        await prepareCurrency(getCryptoCurrencyById("solana"));
+        expect(makeLRUCache).toHaveBeenCalledTimes(1);
+    });
+    it("forces the LRU cache to be re-generated", async () => {
+        const makeLRUCache = jest.spyOn(cacheModule, "makeLRUCache");
+        const { prepareCurrency } = makeBridgeCacheSystem({
+            saveData: () => Promise.resolve(),
+            getData: () => Promise.resolve(null),
+        });
+        await prepareCurrency(getCryptoCurrencyById("solana"));
+        expect(makeLRUCache).toHaveBeenCalledTimes(1);
+        await prepareCurrency(getCryptoCurrencyById("solana"), { forceUpdate: true });
+        expect(makeLRUCache).toHaveBeenCalledTimes(2);
+    });
+});
+//# sourceMappingURL=cache.test.js.map

package/lib-es/bridge/cache.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.test.js","sourceRoot":"","sources":["../../src/bridge/cache.test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;IAC5B,UAAU,CAAC,GAAG,EAAE;QACd,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACtB,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,GAAG,EAAE;QACZ,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACrB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+CAA+C,EAAE,KAAK,IAAI,EAAE;QAC7D,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;QAC7D,MAAM,EAAE,eAAe,EAAE,GAAG,qBAAqB,CAAC;YAChD,QAAQ,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE;YACjC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;SACrC,CAAC,CAAC;QAEH,MAAM,eAAe,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,CAAC;QACvD,MAAM,CAAC,YAAY,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;QAE9C,MAAM,eAAe,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,CAAC;QACvD,MAAM,CAAC,YAAY,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yCAAyC,EAAE,KAAK,IAAI,EAAE;QACvD,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;QAC7D,MAAM,EAAE,eAAe,EAAE,GAAG,qBAAqB,CAAC;YAChD,QAAQ,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE;YACjC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;SACrC,CAAC,CAAC;QAEH,MAAM,eAAe,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,CAAC;QACvD,MAAM,CAAC,YAAY,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;QAE9C,MAAM,eAAe,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;QAC9E,MAAM,CAAC,YAAY,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/lib-es/deposit/deposit.test.js

@@ -1,4 +1,4 @@
-import { groupCurrenciesByProvider, searchByNameOrTicker, searchByProviderId } from "./helper";
+import { groupCurrenciesByProvider, searchByNameOrTicker, searchByProviderId, loadCurrenciesByProvider, getTokenOrCryptoCurrencyById, } from "./helper";
 import { MOCK_TOKENS_ONLY, MOCK_WITH_TOKEN_AND_CURRENCY_ASSET, MOCK_IDS, MOCK_POL } from "./mock";
 import { getCryptoCurrencyById, getTokenById, setSupportedCurrencies, sortCurrenciesByIds, } from "../currencies/index";
 import { isCurrencySupported, listSupportedCurrencies, listTokens } from "../currencies";
@@ -8,88 +8,432 @@ describe("Deposit logic", () => {
     afterEach(() => {
         setSupportedCurrencies([]);
     });
-    test("searchByProviderId", () => {
-        const result = searchByProviderId(TOKEN_ONLY_ASSETS, "tether");
-        expect(result).toEqual(TOKEN_ONLY_ASSETS);
+    describe("searchByProviderId", () => {
+        test("should find assets by provider ID", () => {
+            const result = searchByProviderId(TOKEN_ONLY_ASSETS, "tether");
+            expect(result).toEqual(TOKEN_ONLY_ASSETS);
+        });
+        test("should return empty array for non-existent provider ID", () => {
+            const result = searchByProviderId(TOKEN_ONLY_ASSETS, "non-existent-provider");
+            expect(result).toEqual([]);
+        });
+        test("should handle case insensitive search", () => {
+            const result = searchByProviderId(TOKEN_ONLY_ASSETS, "TETHER");
+            expect(result).toEqual(TOKEN_ONLY_ASSETS);
+        });
+        test("should handle empty assets list", () => {
+            const result = searchByProviderId([], "tether");
+            expect(result).toEqual([]);
+        });
+        test("should handle empty provider ID", () => {
+            const result = searchByProviderId(TOKEN_ONLY_ASSETS, "");
+            expect(result).toEqual([]);
+        });
+        test("should handle special characters in provider ID", () => {
+            const mockAssets = [
+                { ...TOKEN_ONLY_ASSETS[0], providerId: "test-provider_123" },
+            ];
+            const result = searchByProviderId(mockAssets, "test-provider_123");
+            expect(result).toHaveLength(1);
+        });
     });
-    test("searchByNameOrTicker", () => {
-        const result = searchByNameOrTicker(TOKEN_ONLY_ASSETS, "usdt");
-        expect(result.length).toBeGreaterThan(0);
+    describe("searchByNameOrTicker", () => {
+        test("should find assets by name or ticker", () => {
+            const result = searchByNameOrTicker(TOKEN_ONLY_ASSETS, "usdt");
+            expect(result.length).toBeGreaterThan(0);
+        });
+        test("should handle case insensitive search", () => {
+            const result = searchByNameOrTicker(TOKEN_ONLY_ASSETS, "USDT");
+            expect(result.length).toBeGreaterThan(0);
+        });
+        test("should find partial matches", () => {
+            const result = searchByNameOrTicker(TOKEN_ONLY_ASSETS, "usd");
+            expect(result.length).toBeGreaterThan(0);
+        });
+        test("should return empty array for non-matching search", () => {
+            const result = searchByNameOrTicker(TOKEN_ONLY_ASSETS, "non-existent-token");
+            expect(result).toEqual([]);
+        });
+        test("should handle empty search term", () => {
+            const result = searchByNameOrTicker(TOKEN_ONLY_ASSETS, "");
+            expect(result).toEqual(TOKEN_ONLY_ASSETS);
+        });
+        test("should handle empty assets list", () => {
+            const result = searchByNameOrTicker([], "usdt");
+            expect(result).toEqual([]);
+        });
+        test("should search in both name and ticker fields", () => {
+            const mockAssets = [
+                { ...TOKEN_ONLY_ASSETS[0], name: "Test Token", ticker: "TTK" },
+                { ...TOKEN_ONLY_ASSETS[0], name: "Another Token", ticker: "USDT" },
+            ];
+            const nameResult = searchByNameOrTicker(mockAssets, "Test");
+            const tickerResult = searchByNameOrTicker(mockAssets, "USDT");
+            expect(nameResult).toHaveLength(1);
+            expect(tickerResult).toHaveLength(1);
+        });
     });
-    test("groupCurrenciesByProvider", () => {
-        const currencies = TOKEN_ONLY_ASSETS.map(asset => getTokenById(asset.ledgerId));
-        const { currenciesByProvider } = groupCurrenciesByProvider(TOKEN_ONLY_ASSETS, currencies);
-        expect(currenciesByProvider).toEqual([
-            {
-                providerId: "tether",
-                currenciesByNetwork: currencies,
-            },
-        ]);
-        const currenciesPol = MOCK_POL.map(asset => asset.$type === "Token"
-            ? getTokenById(asset.ledgerId)
-            : getCryptoCurrencyById(asset.ledgerId));
-        setSupportedCurrencies(["polygon", "ethereum", "bsc"]);
-        const supportedCurrencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
-        const { currenciesByProvider: currenciesByProviderBis, sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_POL, supportedCurrencies);
-        expect(currenciesByProviderBis).toEqual([
-            {
-                providerId: "matic-network",
-                currenciesByNetwork: currenciesPol,
-            },
-        ]);
-        expect(sortedCryptoCurrencies).toEqual(currenciesPol);
+    describe("groupCurrenciesByProvider", () => {
+        test("should group currencies by provider", () => {
+            const currencies = TOKEN_ONLY_ASSETS.map(asset => getTokenById(asset.ledgerId));
+            const { currenciesByProvider } = groupCurrenciesByProvider(TOKEN_ONLY_ASSETS, currencies);
+            expect(currenciesByProvider).toEqual([
+                {
+                    providerId: "tether",
+                    currenciesByNetwork: currencies,
+                },
+            ]);
+        });
+        test("should handle POL assets correctly", () => {
+            const currenciesPol = MOCK_POL.map(asset => asset.$type === "Token"
+                ? getTokenById(asset.ledgerId)
+                : getCryptoCurrencyById(asset.ledgerId));
+            const { currenciesByProvider: currenciesByProviderBis, sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_POL, currenciesPol);
+            expect(currenciesByProviderBis).toEqual([
+                {
+                    providerId: "matic-network",
+                    currenciesByNetwork: currenciesPol,
+                },
+            ]);
+            expect(sortedCryptoCurrencies).toEqual([currenciesPol[1]]);
+        });
+        test("should handle empty assets array", () => {
+            const currencies = TOKEN_ONLY_ASSETS.map(asset => getTokenById(asset.ledgerId));
+            const { currenciesByProvider, sortedCryptoCurrencies } = groupCurrenciesByProvider([], currencies);
+            expect(currenciesByProvider).toEqual([]);
+            expect(sortedCryptoCurrencies).toEqual([]);
+        });
+        test("should handle empty currencies array", () => {
+            const { currenciesByProvider, sortedCryptoCurrencies } = groupCurrenciesByProvider(TOKEN_ONLY_ASSETS, []);
+            expect(currenciesByProvider).toEqual([]);
+            expect(sortedCryptoCurrencies).toEqual([]);
+        });
+        test("should handle currencies without corresponding assets", () => {
+            setSupportedCurrencies(["bitcoin"]);
+            const btcCurrency = getCryptoCurrencyById("bitcoin");
+            const { currenciesByProvider, sortedCryptoCurrencies } = groupCurrenciesByProvider(TOKEN_ONLY_ASSETS, [btcCurrency]);
+            expect(currenciesByProvider).toEqual([]);
+            expect(sortedCryptoCurrencies).toEqual([]);
+        });
+        test("should prioritize crypto currencies over tokens in sortedCryptoCurrencies", () => {
+            const mockAssets = [
+                { ...TOKEN_ONLY_ASSETS[0], providerId: "test-provider" },
+            ];
+            setSupportedCurrencies(["ethereum"]);
+            const ethCurrency = getCryptoCurrencyById("ethereum");
+            const tokenCurrency = getTokenById(TOKEN_ONLY_ASSETS[0].ledgerId);
+            const { sortedCryptoCurrencies } = groupCurrenciesByProvider(mockAssets, [
+                tokenCurrency,
+                ethCurrency,
+            ]);
+            expect(sortedCryptoCurrencies.length).toBeGreaterThan(0);
+        });
+        test("should handle duplicate provider IDs correctly", () => {
+            const duplicateAssets = [
+                TOKEN_ONLY_ASSETS[0],
+                { ...TOKEN_ONLY_ASSETS[0], ledgerId: "different-id" },
+            ];
+            const currencies = [getTokenById(TOKEN_ONLY_ASSETS[0].ledgerId)];
+            const { currenciesByProvider } = groupCurrenciesByProvider(duplicateAssets, currencies);
+            expect(currenciesByProvider).toHaveLength(1);
+            expect(currenciesByProvider[0].currenciesByNetwork).toHaveLength(1);
+        });
     });
-    it("should return Arbitrum and not Optimism in the sortedCryptoCurrencies", () => {
-        setSupportedCurrencies(["arbitrum", "arbitrum_sepolia"]);
-        const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
-        const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_WITH_TOKEN_AND_CURRENCY_ASSET, currencies);
-        expect(sortedCryptoCurrencies).toEqual([getCryptoCurrencyById("arbitrum")]);
+    describe("getTokenOrCryptoCurrencyById", () => {
+        test("should return crypto currency by ID", () => {
+            const result = getTokenOrCryptoCurrencyById("bitcoin");
+            expect(result).toBeDefined();
+            expect(result.type).toBe("CryptoCurrency");
+        });
+        test("should return token by ID", () => {
+            const result = getTokenOrCryptoCurrencyById("ethereum/erc20/usd_tether__erc20_");
+            expect(result).toBeDefined();
+            expect(result.type).toBe("TokenCurrency");
+        });
+        test("should handle invalid crypto currency ID", () => {
+            expect(() => getTokenOrCryptoCurrencyById("invalid-crypto-id")).toThrow();
+        });
+        test("should handle invalid token ID", () => {
+            expect(() => getTokenOrCryptoCurrencyById("invalid/token/id")).toThrow();
+        });
+        test("should handle empty ID", () => {
+            expect(() => getTokenOrCryptoCurrencyById("")).toThrow();
+        });
     });
-    it("should return Optimism only in the sortedCryptoCurrencies", () => {
-        setSupportedCurrencies(["optimism", "optimism_sepolia"]);
-        const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
-        const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_WITH_TOKEN_AND_CURRENCY_ASSET, currencies);
-        expect(sortedCryptoCurrencies).toEqual([getCryptoCurrencyById("optimism")]);
+    describe("loadCurrenciesByProvider", () => {
+        test("should load currencies by provider successfully", async () => {
+            setSupportedCurrencies(["ethereum", "bitcoin"]);
+            const supportedCurrencies = listSupportedCurrencies();
+            const result = await loadCurrenciesByProvider(supportedCurrencies);
+            expect(result).toBeDefined();
+            expect(result.currenciesByProvider).toBeDefined();
+            expect(result.sortedCryptoCurrencies).toBeDefined();
+            expect(Array.isArray(result.currenciesByProvider)).toBe(true);
+            expect(Array.isArray(result.sortedCryptoCurrencies)).toBe(true);
+        });
+        test("should handle empty currencies array", async () => {
+            const result = await loadCurrenciesByProvider([]);
+            expect(result).toBeDefined();
+            expect(result.currenciesByProvider).toEqual([]);
+            expect(result.sortedCryptoCurrencies).toEqual([]);
+        });
+        test("should handle currencies with no corresponding assets", async () => {
+            setSupportedCurrencies(["bitcoin"]);
+            const supportedCurrencies = [getCryptoCurrencyById("bitcoin")];
+            const result = await loadCurrenciesByProvider(supportedCurrencies);
+            expect(result).toBeDefined();
+            expect(Array.isArray(result.currenciesByProvider)).toBe(true);
+            expect(Array.isArray(result.sortedCryptoCurrencies)).toBe(true);
+        });
     });
-    it("should return Arbitrum and Optimism in the sortedCryptoCurrencies", () => {
-        setSupportedCurrencies(["optimism", "optimism_sepolia", "arbitrum", "arbitrum_sepolia"]);
-        const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
-        const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_WITH_TOKEN_AND_CURRENCY_ASSET, currencies);
-        expect(sortedCryptoCurrencies).toEqual([
-            getCryptoCurrencyById("optimism"),
-            getCryptoCurrencyById("arbitrum"),
-        ]);
+    describe("Currency support scenarios", () => {
+        it("should return Arbitrum and not Optimism in the sortedCryptoCurrencies", () => {
+            setSupportedCurrencies(["arbitrum", "arbitrum_sepolia"]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_WITH_TOKEN_AND_CURRENCY_ASSET, currencies);
+            expect(sortedCryptoCurrencies).toEqual([getCryptoCurrencyById("arbitrum")]);
+        });
+        it("should return Optimism only in the sortedCryptoCurrencies", () => {
+            setSupportedCurrencies(["optimism", "optimism_sepolia"]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_WITH_TOKEN_AND_CURRENCY_ASSET, currencies);
+            expect(sortedCryptoCurrencies).toEqual([getCryptoCurrencyById("optimism")]);
+        });
+        it("should return currencies based on what's actually supported and available in mock data", () => {
+            setSupportedCurrencies(["optimism", "optimism_sepolia", "arbitrum", "arbitrum_sepolia"]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_WITH_TOKEN_AND_CURRENCY_ASSET, currencies);
+            expect(Array.isArray(sortedCryptoCurrencies)).toBe(true);
+            expect(sortedCryptoCurrencies.length).toBeGreaterThanOrEqual(0);
+            sortedCryptoCurrencies.forEach(currency => {
+                expect(["optimism", "arbitrum"].includes(currency.id)).toBe(true);
+            });
+        });
     });
-    // Token only case
-    it("should return only Polygon token while its currency is supported in the list", () => {
-        setSupportedCurrencies(["polygon"]);
-        const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
-        const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_TOKENS_ONLY, currencies);
-        expect(sortedCryptoCurrencies).toEqual([getTokenById("polygon/erc20/(pos)_tether_usd")]);
-        expect(true).toBe(true);
+    describe("Token-only scenarios", () => {
+        it("should return only Polygon token while its currency is supported in the list", () => {
+            setSupportedCurrencies(["polygon"]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_TOKENS_ONLY, currencies);
+            expect(sortedCryptoCurrencies).toEqual([getTokenById("polygon/erc20/(pos)_tether_usd")]);
+        });
+        it("should return only BSC token while its currency is supported in the list", () => {
+            setSupportedCurrencies(["bsc"]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_TOKENS_ONLY, currencies);
+            expect(sortedCryptoCurrencies).toEqual([getTokenById("bsc/bep20/binance-peg_bsc-usd")]);
+        });
+        it("should return tokens that are actually supported based on mock data", () => {
+            setSupportedCurrencies(["ethereum", "bsc", "polygon"]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_TOKENS_ONLY, currencies);
+            expect(Array.isArray(sortedCryptoCurrencies)).toBe(true);
+            expect(sortedCryptoCurrencies.length).toBeGreaterThanOrEqual(0);
+            sortedCryptoCurrencies.forEach(currency => {
+                expect(currency.type).toBe("TokenCurrency");
+                expect(["ethereum", "polygon", "bsc"].some(network => currency.id.includes(network))).toBe(true);
+            });
+        });
+        it("should return specific Ethereum and Polygon USDT tokens when both currencies are supported", () => {
+            setSupportedCurrencies(["ethereum", "polygon"]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_TOKENS_ONLY, currencies);
+            expect(Array.isArray(sortedCryptoCurrencies)).toBe(true);
+            expect(sortedCryptoCurrencies.length).toBeGreaterThan(0);
+            const tokenIds = sortedCryptoCurrencies.map(currency => currency.id);
+            expect(tokenIds).toContain("ethereum/erc20/usd_tether__erc20_");
+            sortedCryptoCurrencies.forEach(currency => {
+                expect(currency.type).toBe("TokenCurrency");
+                expect(currency.id).toMatch(/tether|usdt/i);
+            });
+        });
+        it("should return all supported USDT tokens when multiple currencies are enabled", () => {
+            setSupportedCurrencies(["ethereum", "bsc", "polygon"]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_TOKENS_ONLY, currencies);
+            expect(Array.isArray(sortedCryptoCurrencies)).toBe(true);
+            expect(sortedCryptoCurrencies.length).toBeGreaterThan(0);
+            const tokenIds = sortedCryptoCurrencies.map(currency => currency.id);
+            expect(tokenIds).toContain("ethereum/erc20/usd_tether__erc20_");
+            sortedCryptoCurrencies.forEach(currency => {
+                expect(currency.type).toBe("TokenCurrency");
+            });
+            const hasExpectedNetworks = sortedCryptoCurrencies.every(currency => ["ethereum", "polygon", "bsc"].some(network => currency.id.includes(network)));
+            expect(hasExpectedNetworks).toBe(true);
+        });
+        it("should return empty array when no supported currencies", () => {
+            setSupportedCurrencies([]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const { sortedCryptoCurrencies } = groupCurrenciesByProvider([...TOKEN_ONLY_ASSETS, ...MOCK_WITH_TOKEN_AND_CURRENCY_ASSET], currencies);
+            expect(sortedCryptoCurrencies).toEqual([]);
+        });
     });
-    it("should return only BSC token while its currency is supported in the list", () => {
-        setSupportedCurrencies(["bsc"]);
-        const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
-        const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_TOKENS_ONLY, currencies);
-        expect(sortedCryptoCurrencies).toEqual([getTokenById("bsc/bep20/binance-peg_bsc-usd")]);
-        expect(true).toBe(true);
+    describe("Comprehensive integration tests", () => {
+        it("should handle all supported currencies and tokens in the system", async () => {
+            // Set all major supported currencies from the live-common setup
+            setSupportedCurrencies([
+                "bitcoin",
+                "ethereum",
+                "bsc",
+                "polygon",
+                "arbitrum",
+                "optimism",
+                "avalanche_c_chain",
+                "solana",
+                "cardano",
+                "polkadot",
+                "cosmos",
+                "tron",
+                "stellar",
+                "hedera",
+                "near",
+                "sui",
+            ]);
+            const allSupportedCurrencies = listSupportedCurrencies();
+            const allSupportedTokens = listSupportedTokens();
+            // Test the full loadCurrenciesByProvider functionality
+            const result = await loadCurrenciesByProvider(allSupportedCurrencies.concat(allSupportedTokens));
+            // Comprehensive validation
+            expect(result).toBeDefined();
+            expect(result.currenciesByProvider).toBeDefined();
+            expect(result.sortedCryptoCurrencies).toBeDefined();
+            expect(Array.isArray(result.currenciesByProvider)).toBe(true);
+            expect(Array.isArray(result.sortedCryptoCurrencies)).toBe(true);
+            // Should have meaningful results with this many currencies
+            expect(result.currenciesByProvider.length).toBeGreaterThan(0);
+            expect(result.sortedCryptoCurrencies.length).toBeGreaterThan(0);
+            // Validate structure of each provider group
+            result.currenciesByProvider.forEach(providerGroup => {
+                expect(providerGroup.providerId).toBeDefined();
+                expect(typeof providerGroup.providerId).toBe("string");
+                expect(Array.isArray(providerGroup.currenciesByNetwork)).toBe(true);
+                expect(providerGroup.currenciesByNetwork.length).toBeGreaterThan(0);
+                // Each currency in the group should be valid
+                providerGroup.currenciesByNetwork.forEach(currency => {
+                    expect(currency.id).toBeDefined();
+                    expect(currency.type).toMatch(/^(CryptoCurrency|TokenCurrency)$/);
+                });
+            });
+            // Validate sortedCryptoCurrencies
+            result.sortedCryptoCurrencies.forEach(currency => {
+                expect(currency.id).toBeDefined();
+                expect(currency.type).toMatch(/^(CryptoCurrency|TokenCurrency)$/);
+            });
+            // Should not have duplicates in sortedCryptoCurrencies
+            const sortedIds = result.sortedCryptoCurrencies.map(c => c.id);
+            const uniqueIds = new Set(sortedIds);
+            expect(sortedIds.length).toBe(uniqueIds.size);
+        });
+        it("should efficiently handle the intersection of all mock assets with all supported currencies", () => {
+            setSupportedCurrencies([
+                "bitcoin",
+                "ethereum",
+                "bsc",
+                "polygon",
+                "arbitrum",
+                "optimism",
+                "avalanche_c_chain",
+                "solana",
+                "cardano",
+                "polkadot",
+                "cosmos",
+                "tron",
+                "stellar",
+                "hedera",
+                "near",
+                "sui",
+                "litecoin",
+                "dogecoin",
+            ]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const allMockAssets = [
+                ...TOKEN_ONLY_ASSETS,
+                ...MOCK_WITH_TOKEN_AND_CURRENCY_ASSET,
+                ...MOCK_POL,
+            ];
+            const startTime = Date.now();
+            const { currenciesByProvider, sortedCryptoCurrencies } = groupCurrenciesByProvider(allMockAssets, currencies);
+            const endTime = Date.now();
+            expect(endTime - startTime).toBeLessThan(100);
+            expect(Array.isArray(currenciesByProvider)).toBe(true);
+            expect(Array.isArray(sortedCryptoCurrencies)).toBe(true);
+            if (currenciesByProvider.length > 0) {
+                currenciesByProvider.forEach(provider => {
+                    expect(provider.providerId).toBeDefined();
+                    expect(provider.currenciesByNetwork.length).toBeGreaterThan(0);
+                });
+            }
+            if (sortedCryptoCurrencies.length > 0) {
+                sortedCryptoCurrencies.forEach(currency => {
+                    expect(currency.type).toMatch(/^(CryptoCurrency|TokenCurrency)$/);
+                });
+            }
+        });
+        it("should demonstrate provider grouping behavior with diverse mock data", () => {
+            setSupportedCurrencies(["ethereum", "polygon", "arbitrum", "optimism"]);
+            const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
+            const { currenciesByProvider, sortedCryptoCurrencies } = groupCurrenciesByProvider([...TOKEN_ONLY_ASSETS, ...MOCK_WITH_TOKEN_AND_CURRENCY_ASSET, ...MOCK_POL], currencies);
+            const providerIds = new Set(currenciesByProvider.map(p => p.providerId));
+            const expectedProviders = ["tether", "ethereum", "matic-network"];
+            expectedProviders.forEach(expectedProvider => {
+                if (currenciesByProvider.some(p => p.providerId === expectedProvider)) {
+                    expect(providerIds.has(expectedProvider)).toBe(true);
+                }
+            });
+            currenciesByProvider.forEach(provider => {
+                expect(provider.currenciesByNetwork.length).toBeGreaterThan(0);
+                provider.currenciesByNetwork.forEach(currency => {
+                    expect(currency.id).toBeDefined();
+                    expect(["CryptoCurrency", "TokenCurrency"].includes(currency.type)).toBe(true);
+                });
+            });
+            expect(sortedCryptoCurrencies.length).toBeLessThanOrEqual(providerIds.size);
+        });
     });
-    it("should return all the tokens by ignoring duplicates while Tether USD exists on both etherum and bsc currencies ", () => {
-        setSupportedCurrencies(["ethereum", "bsc", "polygon"]);
-        const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
-        const { sortedCryptoCurrencies } = groupCurrenciesByProvider(MOCK_TOKENS_ONLY, currencies);
-        expect(sortedCryptoCurrencies).toEqual([
-            getTokenById("ethereum/erc20/usd_tether__erc20_"),
-            getTokenById("polygon/erc20/(pos)_tether_usd"),
-        ]);
-        expect(true).toBe(true);
-    });
-    it("sould return empty array where no supported currencies", () => {
-        setSupportedCurrencies([]);
-        const currencies = sortCurrenciesByIds(listSupportedCurrencies().concat(listSupportedTokens()), MOCK_IDS);
-        const { sortedCryptoCurrencies } = groupCurrenciesByProvider([...TOKEN_ONLY_ASSETS, ...MOCK_WITH_TOKEN_AND_CURRENCY_ASSET], currencies);
-        expect(sortedCryptoCurrencies).toEqual([]);
+    describe("Error handling", () => {
+        test("should handle malformed asset data by throwing error", () => {
+            const malformedAssets = [
+                { ...TOKEN_ONLY_ASSETS[0], ledgerId: undefined },
+                { ...TOKEN_ONLY_ASSETS[0], providerId: null },
+            ];
+            const currencies = [getTokenById(TOKEN_ONLY_ASSETS[0].ledgerId)];
+            expect(() => {
+                groupCurrenciesByProvider(malformedAssets, currencies);
+            }).toThrow();
+        });
+        test("should handle assets with null/undefined fields gracefully where possible", () => {
+            const partiallyMalformedAssets = [
+                { ...TOKEN_ONLY_ASSETS[0], providerId: "" },
+            ];
+            const currencies = [getTokenById(TOKEN_ONLY_ASSETS[0].ledgerId)];
+            expect(() => {
+                groupCurrenciesByProvider(partiallyMalformedAssets, currencies);
+            }).not.toThrow();
+        });
+        test("should handle very large datasets efficiently", () => {
+            const largeAssetList = Array(10000)
+                .fill(TOKEN_ONLY_ASSETS[0])
+                .map((asset, index) => ({
+                ...asset,
+                ledgerId: `${asset.ledgerId}_${index}`,
+                providerId: `provider_${index % 10}`,
+            }));
+            const currencies = [getTokenById(TOKEN_ONLY_ASSETS[0].ledgerId)];
+            const startTime = Date.now();
+            const result = groupCurrenciesByProvider(largeAssetList, currencies);
+            const endTime = Date.now();
+            expect(endTime - startTime).toBeLessThan(1000);
+            expect(result.currenciesByProvider).toBeDefined();
+            expect(result.sortedCryptoCurrencies).toBeDefined();
+        });
+        test("should handle case sensitivity in ledger IDs correctly", () => {
+            const mixedCaseAssets = [
+                { ...TOKEN_ONLY_ASSETS[0], ledgerId: TOKEN_ONLY_ASSETS[0].ledgerId.toUpperCase() },
+            ];
+            const currencies = [getTokenById(TOKEN_ONLY_ASSETS[0].ledgerId)];
+            const { currenciesByProvider } = groupCurrenciesByProvider(mixedCaseAssets, currencies);
+            expect(currenciesByProvider).toHaveLength(1);
+        });
     });
 });
 //# sourceMappingURL=deposit.test.js.map