@ledgerhq/live-common 34.43.0 → 34.44.0-nightly.1

package/src/families/stellar/ui.ts

@@ -0,0 +1,15 @@
+import { StellarOperationExtra } from "./types";
+
+/**
+ * Format stellar memo value for display.
+ */
+export const formatMemo = (extra: StellarOperationExtra): string | undefined => {
+  switch (extra?.memo?.type) {
+    case "MEMO_ID":
+    case "MEMO_TEXT":
+    case "MEMO_HASH":
+    case "MEMO_RETURN":
+      return extra?.memo.value;
+  }
+  return undefined;
+};

package/src/families/tron/data.mock.ts

@@ -1,10 +1,18 @@
 import { fromAccountRaw } from "../../account/serialization";
 import { TronAccount } from "@ledgerhq/coin-tron/types/index";
+import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
+import { CryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/type";
 
 export const __NEXT_REWARD_DATE__ = new Date(Date.now() - 6 * 60 * 60 * 1000);
 
 export const __LAST_VOTING_DATE__ = new Date(Date.now() - 6 * 60 * 60 * 1000);
 
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+setCryptoAssetsStoreForCoinFramework({
+  findTokenById: (_: string) => undefined,
+  findTokenByAddressInCurrency: (_: string, __: string) => undefined,
+} as unknown as CryptoAssetsStore);
+
 export const mockAccount = fromAccountRaw({
   id: "js:2:tron:TRON_ID:",
   seedIdentifier: "TRON_ID",

package/src/featureFlags/defaultFeatures.ts

@@ -95,6 +95,7 @@ export const CURRENCY_DEFAULT_FEATURES = {
   currencySeiNetworkEvm: DEFAULT_FEATURE,
   currencyBerachain: DEFAULT_FEATURE,
   currencyHyperevm: DEFAULT_FEATURE,
+  currencyCantonNetwork: DEFAULT_FEATURE,
 };
 
 /**

package/src/generated/bridge/js.ts

@@ -3,6 +3,7 @@ import { bridge as aptos } from "../../families/aptos/setup";
 import { bridge as bitcoin } from "../../families/bitcoin/setup";
 import { bridge as cardano } from "../../families/cardano/setup";
 import { bridge as casper } from "../../families/casper/setup";
+import { bridge as canton } from "../../families/canton/setup";
 import { bridge as celo } from "../../families/celo/setup";
 import { bridge as cosmos } from "../../families/cosmos/setup";
 import { bridge as evm } from "../../families/evm/setup";
@@ -29,6 +30,7 @@ export default {
   bitcoin,
   cardano,
   casper,
+  canton,
   celo,
   cosmos,
   evm,

package/src/generated/cli-transaction.ts

@@ -3,6 +3,7 @@ import { cliTools as aptos } from "../families/aptos/setup";
 import { cliTools as bitcoin } from "../families/bitcoin/setup";
 import { cliTools as cardano } from "../families/cardano/setup";
 import { cliTools as casper } from "../families/casper/setup";
+import { cliTools as canton } from "../families/canton/setup";
 import { cliTools as celo } from "../families/celo/setup";
 import { cliTools as cosmos } from "../families/cosmos/setup";
 import { cliTools as evm } from "../families/evm/setup";
@@ -30,6 +31,7 @@ export default {
   bitcoin,
   cardano,
   casper,
+  canton,
   celo,
   cosmos,
   evm,

package/src/generated/deviceTransactionConfig.ts

@@ -3,6 +3,7 @@ import aptos from "@ledgerhq/coin-aptos/deviceTransactionConfig";
 import bitcoin from "@ledgerhq/coin-bitcoin/deviceTransactionConfig";
 import cardano from "@ledgerhq/coin-cardano/deviceTransactionConfig";
 import casper from "@ledgerhq/coin-casper/deviceTransactionConfig";
+import canton from "@ledgerhq/coin-canton/deviceTransactionConfig";
 import celo from "@ledgerhq/coin-celo/deviceTransactionConfig";
 import cosmos from "@ledgerhq/coin-cosmos/deviceTransactionConfig";
 import evm from "@ledgerhq/coin-evm/deviceTransactionConfig";
@@ -28,6 +29,7 @@ export default {
   bitcoin,
   cardano,
   casper,
+  canton,
   celo,
   cosmos,
   evm,

package/src/generated/hw-getAddress.ts

@@ -3,6 +3,7 @@ import { resolver as aptos } from "../families/aptos/setup";
 import { resolver as bitcoin } from "../families/bitcoin/setup";
 import { resolver as cardano } from "../families/cardano/setup";
 import { resolver as casper } from "../families/casper/setup";
+import { resolver as canton } from "../families/canton/setup";
 import { resolver as celo } from "../families/celo/setup";
 import { resolver as cosmos } from "../families/cosmos/setup";
 import { resolver as evm } from "../families/evm/setup";
@@ -30,6 +31,7 @@ export default {
   bitcoin,
   cardano,
   casper,
+  canton,
   celo,
   cosmos,
   evm,

package/src/generated/specs.ts

@@ -3,6 +3,7 @@ import aptos from "@ledgerhq/coin-aptos/specs";
 import bitcoin from "@ledgerhq/coin-bitcoin/specs";
 import cardano from "@ledgerhq/coin-cardano/specs";
 import casper from "@ledgerhq/coin-casper/specs";
+import canton from "@ledgerhq/coin-canton/specs";
 import celo from "@ledgerhq/coin-celo/specs";
 import cosmos from "@ledgerhq/coin-cosmos/specs";
 import evm from "@ledgerhq/coin-evm/specs";
@@ -29,6 +30,7 @@ export default {
   bitcoin,
   cardano,
   casper,
+  canton,
   celo,
   cosmos,
   evm,

package/src/generated/transaction.ts

@@ -3,6 +3,7 @@ import aptos from "@ledgerhq/coin-aptos/transaction";
 import bitcoin from "@ledgerhq/coin-bitcoin/transaction";
 import cardano from "@ledgerhq/coin-cardano/transaction";
 import casper from "@ledgerhq/coin-casper/transaction";
+import canton from "@ledgerhq/coin-canton/transaction";
 import celo from "@ledgerhq/coin-celo/transaction";
 import cosmos from "@ledgerhq/coin-cosmos/transaction";
 import evm from "@ledgerhq/coin-evm/transaction";
@@ -30,6 +31,7 @@ export default {
   bitcoin,
   cardano,
   casper,
+  canton,
   celo,
   cosmos,
   evm,

package/src/generated/types.ts

@@ -16,6 +16,12 @@ import type {
   TransactionStatus as bitcoinTransactionStatus,
   TransactionStatusRaw as bitcoinTransactionStatusRaw,
 } from "@ledgerhq/coin-bitcoin/types";
+import type {
+  Transaction as cantonTransaction,
+  TransactionRaw as cantonTransactionRaw,
+  TransactionStatus as cantonTransactionStatus,
+  TransactionStatusRaw as cantonTransactionStatusRaw,
+} from "@ledgerhq/coin-canton/types/index";
 import type {
   Transaction as cardanoTransaction,
   TransactionRaw as cardanoTransactionRaw,
@@ -153,6 +159,7 @@ export type Transaction =
   | algorandTransaction
   | aptosTransaction
   | bitcoinTransaction
+  | cantonTransaction
   | cardanoTransaction
   | casperTransaction
   | celoTransaction
@@ -180,6 +187,7 @@ export type TransactionRaw =
   | algorandTransactionRaw
   | aptosTransactionRaw
   | bitcoinTransactionRaw
+  | cantonTransactionRaw
   | cardanoTransactionRaw
   | casperTransactionRaw
   | celoTransactionRaw
@@ -207,6 +215,7 @@ export type TransactionStatus =
   | algorandTransactionStatus
   | aptosTransactionStatus
   | bitcoinTransactionStatus
+  | cantonTransactionStatus
   | cardanoTransactionStatus
   | casperTransactionStatus
   | celoTransactionStatus
@@ -234,6 +243,7 @@ export type TransactionStatusRaw =
   | algorandTransactionStatusRaw
   | aptosTransactionStatusRaw
   | bitcoinTransactionStatusRaw
+  | cantonTransactionStatusRaw
   | cardanoTransactionStatusRaw
   | casperTransactionStatusRaw
   | celoTransactionStatusRaw

package/src/modularDrawer/__mocks__/accounts.mock.ts

@@ -0,0 +1,43 @@
+import { genAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
+import BigNumber from "bignumber.js";
+import { mockBtcCryptoCurrency } from "./currencies.mock";
+import { mockArbitrumCryptoCurrency } from "./currencies.mock";
+import { mockEthCryptoCurrency } from "./currencies.mock";
+import { mockBaseCryptoCurrency } from "./currencies.mock";
+import { mockScrollCryptoCurrency } from "./currencies.mock";
+
+export const MOCKED_ARB_ACCOUNT = {
+  type: "Account",
+  id: "arbitrum1",
+  balance: new BigNumber(34455),
+  creationDate: "2024-12-10T09:27:22.000Z",
+  currency: mockArbitrumCryptoCurrency,
+  derivationMode: "",
+  freshAddress: "s37rhmi7hsm3i73hsm7i3hm83m8h87hsm87h3s8h33",
+};
+
+export const ETH_ACCOUNT = genAccount("ethereum-1", {
+  currency: mockEthCryptoCurrency,
+});
+export const ETH_ACCOUNT_2 = genAccount("ethereum-2", {
+  currency: mockEthCryptoCurrency,
+});
+export const BTC_ACCOUNT = genAccount("bitcoin-1", {
+  currency: mockBtcCryptoCurrency,
+});
+export const ARB_ACCOUNT = genAccount("arbitrum-1", {
+  currency: mockArbitrumCryptoCurrency,
+  tokenIds: ["arbitrum/erc20/arbitrum"],
+});
+export const ETH_ACCOUNT_WITH_USDC = genAccount("ethereum-usdc", {
+  currency: mockEthCryptoCurrency,
+  tokenIds: ["ethereum/erc20/usdc"],
+});
+export const BASE_ACCOUNT = genAccount("base-1", {
+  currency: mockBaseCryptoCurrency,
+  operationsSize: 100,
+});
+export const SCROLL_ACCOUNT = genAccount("scroll-1", {
+  currency: mockScrollCryptoCurrency,
+  operationsSize: 100,
+});

package/src/modularDrawer/utils/__tests__/currencyUtils.test.ts

@@ -0,0 +1,126 @@
+import { useGroupedCurrenciesByProvider } from "@ledgerhq/live-common/modularDrawer/__mocks__/useGroupedCurrenciesByProvider.mock";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+import {
+  buildProviderCoverageMap,
+  extractProviderCurrencies,
+  filterProvidersByIds,
+  getProviderCurrency,
+  isProviderToken,
+  safeCurrencyLookup,
+} from "../currencyUtils";
+import {
+  usdcToken,
+  mockBaseCryptoCurrency,
+  mockBtcCryptoCurrency,
+  mockEthCryptoCurrency,
+} from "../../__mocks__/currencies.mock";
+
+describe("safeCurrencyLookup", () => {
+  it("should return the currency if it is found", () => {
+    const currency = safeCurrencyLookup("ethereum");
+    expect(currency).toBeDefined();
+  });
+  it("should return null if the currency is not found", () => {
+    const currency = safeCurrencyLookup("not-a-currency");
+    expect(currency).toBeNull();
+  });
+});
+
+describe("isProviderToken", () => {
+  it("should return true if the currency is a provider token", () => {
+    const baseToken: TokenCurrency = {
+      type: "TokenCurrency",
+      id: "base/erc20/base",
+      contractAddress: "0x0000000000000000000000000000000000000000",
+      parentCurrency: mockBaseCryptoCurrency,
+      tokenType: "erc20",
+      name: "Base",
+      ticker: "BASE",
+      units: [
+        {
+          name: "Base",
+          code: "BASE",
+          magnitude: 18,
+        },
+      ],
+    };
+    const currency = isProviderToken(baseToken, "base");
+    expect(currency).toBe(true);
+  });
+  it("should return false if the currency is not a provider token", () => {
+    const currency = isProviderToken(mockEthCryptoCurrency, "ethereum");
+    expect(currency).toBe(false);
+  });
+});
+
+describe("getProviderCurrency", () => {
+  it("should return the currency if it is a provider currency", () => {
+    const { result } = useGroupedCurrenciesByProvider();
+    const currency = getProviderCurrency(result.currenciesByProvider[0]);
+    expect(currency).toEqual(mockBtcCryptoCurrency);
+  });
+  it("should return the currency if it is a provider token", () => {
+    const { result } = useGroupedCurrenciesByProvider();
+    const currency = getProviderCurrency(result.currenciesByProvider[3]);
+    expect(currency).toEqual(usdcToken);
+  });
+});
+
+describe("buildProviderCoverageMap", () => {
+  it("should build a map of provider coverage correctly", () => {
+    const { result } = useGroupedCurrenciesByProvider();
+    const coverageMap = buildProviderCoverageMap(result.currenciesByProvider);
+
+    expect(coverageMap).toBeInstanceOf(Map);
+    expect(coverageMap.get("bitcoin")).toEqual(new Set(["bitcoin"]));
+    expect(coverageMap.get("ethereum")).toEqual(new Set(["ethereum"]));
+    expect(coverageMap.get("arbitrum")).toEqual(new Set(["ethereum"]));
+    expect(coverageMap.get("base")).toEqual(new Set(["ethereum"]));
+    expect(coverageMap.get("scroll")).toEqual(new Set(["ethereum"]));
+    expect(coverageMap.get("arbitrum/erc20/arbitrum")).toEqual(new Set(["arbitrum"]));
+    expect(coverageMap.get("ethereum/erc20/usd__coin")).toEqual(new Set(["usd-coin"]));
+    expect(coverageMap.get("injective")).toEqual(new Set(["injective-protocol"]));
+  });
+  it("should handle empty input", () => {
+    const coverageMap = buildProviderCoverageMap([]);
+    expect(coverageMap).toBeInstanceOf(Map);
+    expect(coverageMap.size).toBe(0);
+  });
+});
+
+describe("filterProvidersByIds", () => {
+  it("should filter providers by ids correctly #evm", () => {
+    const { result } = useGroupedCurrenciesByProvider();
+    const coverageMap = buildProviderCoverageMap(result.currenciesByProvider);
+    const filteredProviders = filterProvidersByIds(
+      result.currenciesByProvider,
+      new Set(["base"]),
+      coverageMap,
+    );
+    expect(filteredProviders).toHaveLength(1);
+    expect(filteredProviders[0].providerId).toBe("ethereum");
+  });
+  it("should filter providers by ids correctly #bitcoin", () => {
+    const { result } = useGroupedCurrenciesByProvider();
+    const coverageMap = buildProviderCoverageMap(result.currenciesByProvider);
+    const filteredProviders = filterProvidersByIds(
+      result.currenciesByProvider,
+      new Set(["bitcoin"]),
+      coverageMap,
+    );
+    expect(filteredProviders).toHaveLength(1);
+    expect(filteredProviders[0].providerId).toBe("bitcoin");
+  });
+});
+
+describe("extractProviderCurrencies", () => {
+  it("should extract provider currencies correctly", () => {
+    const { result } = useGroupedCurrenciesByProvider();
+    const providerCurrencies = extractProviderCurrencies(result.currenciesByProvider);
+    expect(providerCurrencies).toHaveLength(5);
+    expect(providerCurrencies[0]).toEqual(mockBtcCryptoCurrency);
+    expect(providerCurrencies[1].id).toBe("ethereum");
+    expect(providerCurrencies[2].id).toBe("arbitrum/erc20/arbitrum");
+  });
+});

package/src/modularDrawer/utils/currencyUtils.ts

@@ -0,0 +1,95 @@
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { getTokenOrCryptoCurrencyById } from "../../deposit/helper";
+import { isTokenCurrency } from "../../currencies";
+import { CurrenciesByProviderId } from "../../deposit/type";
+
+export type ProviderCoverageMap = Map<string, Set<string>>;
+
+export const safeCurrencyLookup = (id: string): CryptoOrTokenCurrency | null => {
+  try {
+    return getTokenOrCryptoCurrencyById(id);
+  } catch {
+    return null;
+  }
+};
+
+export const isProviderToken = (currency: CryptoOrTokenCurrency, providerId: string): boolean => {
+  return isTokenCurrency(currency) && currency.id.toLowerCase().includes(providerId.toLowerCase());
+};
+
+export const getProviderCurrency = (
+  provider: CurrenciesByProviderId,
+): CryptoOrTokenCurrency | null => {
+  const providerToken = provider.currenciesByNetwork.find(currency => {
+    return isProviderToken(currency, provider.providerId);
+  });
+
+  if (providerToken) {
+    return providerToken;
+  }
+
+  return safeCurrencyLookup(provider.providerId) ?? provider.currenciesByNetwork[0];
+};
+
+export const buildProviderCoverageMap = (
+  providers: CurrenciesByProviderId[],
+): ProviderCoverageMap => {
+  const providerIdToCoveringProviders = new Map<string, Set<string>>();
+
+  for (const { providerId, currenciesByNetwork } of providers) {
+    for (const { id } of currenciesByNetwork) {
+      if (!providerIdToCoveringProviders.has(id)) {
+        providerIdToCoveringProviders.set(id, new Set());
+      }
+      providerIdToCoveringProviders.get(id)!.add(providerId);
+    }
+  }
+
+  return providerIdToCoveringProviders;
+};
+
+export const filterProvidersByIds = (
+  providers: CurrenciesByProviderId[],
+  currencyIdsSet: Set<string>,
+  providerCoverageMap: ProviderCoverageMap,
+): CurrenciesByProviderId[] => {
+  const filtered: CurrenciesByProviderId[] = [];
+
+  for (const provider of providers) {
+    const filteredCurrencies = provider.currenciesByNetwork.filter(currency =>
+      currencyIdsSet.has(currency.id),
+    );
+
+    if (filteredCurrencies.length === 0) continue;
+
+    const providerHasOwnCurrency = provider.currenciesByNetwork.some(
+      currency => currency.id === provider.providerId,
+    );
+
+    if (!providerHasOwnCurrency) {
+      const coveringProviders = providerCoverageMap.get(provider.providerId);
+      const isProviderIdCoveredElsewhere = coveringProviders && coveringProviders.size > 1;
+
+      if (isProviderIdCoveredElsewhere) continue;
+    }
+
+    if (filteredCurrencies.length === provider.currenciesByNetwork.length) {
+      filtered.push(provider);
+    } else {
+      filtered.push({
+        ...provider,
+        currenciesByNetwork: filteredCurrencies,
+      });
+    }
+  }
+
+  return filtered;
+};
+
+export const extractProviderCurrencies = (
+  providers: CurrenciesByProviderId[],
+): CryptoOrTokenCurrency[] => {
+  return providers
+    .map(provider => getProviderCurrency(provider))
+    .filter((currency): currency is CryptoOrTokenCurrency => currency !== null);
+};

package/src/modularDrawer/utils/haveOneCommonProvider.ts

@@ -1,4 +1,4 @@
-import { CurrenciesByProviderId } from "@ledgerhq/live-common/deposit/type";
+import { CurrenciesByProviderId } from "../../deposit/type";
 
 /**
  * This function checks if all currencies in the provided array

package/src/utils/__tests__/composeHooks.test.ts

@@ -0,0 +1,46 @@
+import { composeHooks } from "../composeHooks";
+
+describe("composeHooks", () => {
+  it("should compose hooks and merge their results", () => {
+    const hook1 = (items: Array<{ id: number }>) =>
+      items.map(item => ({ id: item.id, extra: item.id * 2 }));
+    const hook2 = (items: Array<{ id: number; extra: number }>) =>
+      items.map(item => ({ ...item, final: item.extra + 1 }));
+
+    const composed = composeHooks(hook1, hook2);
+
+    const input: Array<{ id: number }> = [{ id: 1 }, { id: 2 }];
+    const processedInput = input.map(item => ({ id: item.id, extra: item.id * 2 }));
+    const result = composed(processedInput);
+
+    expect(result).toEqual([
+      { id: 1, extra: 2, final: 3 },
+      { id: 2, extra: 4, final: 5 },
+    ]);
+  });
+
+  it("should handle hooks that return undefined", () => {
+    const hook1 = (items: Array<{ id: number }>) =>
+      items.map(item => ({ id: item.id, extra: item.id * 2 }));
+    const hook2 = () => undefined;
+
+    const composed = composeHooks(hook1, hook2);
+
+    const input = [{ id: 1 }, { id: 2 }];
+    const result = composed(input);
+
+    expect(result).toEqual([
+      { id: 1, extra: 2 },
+      { id: 2, extra: 4 },
+    ]);
+  });
+
+  it("should return the original items if no hooks are provided", () => {
+    const composed = composeHooks();
+
+    const input = [{ id: 1 }, { id: 2 }];
+    const result = composed(input);
+
+    expect(result).toEqual(input);
+  });
+});

package/src/utils/__tests__/getAccountTuplesForCurrency.test.ts

@@ -0,0 +1,138 @@
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import { genAccount } from "@ledgerhq/live-common/mock/account";
+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { Account, TokenAccount } from "@ledgerhq/types-live";
+import { getAccountTuplesForCurrency } from "../getAccountTuplesForCurrency";
+
+function* accountGenerator(currency: CryptoCurrency): Generator<Account> {
+  let id = 0;
+  while (true) {
+    id += 1;
+    yield genAccount(`mocked-account-${id}`, { currency, operationsSize: 0 });
+  }
+}
+const getAccountCreator = (currencyId: string) => {
+  const generator = accountGenerator(getCryptoCurrencyById(currencyId));
+  return () => generator.next().value;
+};
+
+describe("getAccountTuplesForCurrency", () => {
+  const getEthAccount = getAccountCreator("ethereum");
+  const getBtcAccount = getAccountCreator("bitcoin");
+  const getPolkadotAccount = getAccountCreator("polkadot");
+  const getCosmosAccount = getAccountCreator("cosmos");
+
+  describe("CryptoCurrency", () => {
+    test("returns all accounts associated to the CryptoCurrency", () => {
+      const ethCurrency = getCryptoCurrencyById("ethereum");
+      const ethAccounts = [getEthAccount(), getEthAccount()];
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...ethAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(ethCurrency, allAccounts);
+
+      expect(results).toHaveLength(2);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(ethAccounts[index]);
+        expect(result.subAccount).toBeNull();
+      });
+    });
+
+    test("returns an empty array if the CryptoCurrency passed has no associated account", () => {
+      const ethCurrency = getCryptoCurrencyById("ethereum");
+      const allAccounts: Account[] = [getCosmosAccount(), getBtcAccount(), getPolkadotAccount()];
+
+      const results = getAccountTuplesForCurrency(ethCurrency, allAccounts);
+
+      expect(results).toHaveLength(0);
+    });
+
+    test("filters based on the accountId map", () => {
+      const ethCurrency = getCryptoCurrencyById("ethereum");
+      const ethAccounts = [getEthAccount(), getEthAccount(), getEthAccount(), getEthAccount()];
+
+      const results = getAccountTuplesForCurrency(
+        ethCurrency,
+        ethAccounts,
+        new Map([[ethAccounts[0].id, true]]),
+      );
+
+      expect(results).toHaveLength(1);
+    });
+  });
+
+  describe("TokenCurrency", () => {
+    const aaveToken = getTokenById("ethereum/erc20/aave");
+
+    test("returns correct parent accounts including a new subAccount when a TokenCurrency is provided", () => {
+      const ethAccounts = [
+        { ...getEthAccount(), subAccounts: [] },
+        { ...getEthAccount(), subAccounts: [] },
+      ];
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...ethAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(aaveToken, allAccounts);
+
+      expect(results).toHaveLength(ethAccounts.length);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(ethAccounts[index]);
+        expect((result.subAccount as TokenAccount & { token: TokenCurrency }).token).toEqual(
+          aaveToken,
+        );
+      });
+    });
+
+    test("returns correct parent accounts including already existing subAccounts when a TokenCurrency is provided", () => {
+      const ethAccounts = [{ ...getEthAccount(), subAccounts: [aaveToken] }];
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...ethAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(aaveToken, allAccounts);
+
+      expect(results).toHaveLength(ethAccounts.length);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(ethAccounts[index]);
+        expect((result.subAccount as TokenAccount & { token: TokenCurrency }).token).toEqual(
+          aaveToken,
+        );
+      });
+    });
+
+    test("returns an empty array when a TokenCurrency is provided but the accounts list is empty", () => {
+      const allAccounts: Account[] = [];
+
+      const results = getAccountTuplesForCurrency(aaveToken, allAccounts);
+      expect(results).toHaveLength(0);
+    });
+
+    test("does not filter based on the accountId map", () => {
+      const aaveAccounts = [
+        { ...getEthAccount(), subAccounts: [aaveToken] },
+        { ...getEthAccount(), subAccounts: [aaveToken] },
+        { ...getEthAccount(), subAccounts: [aaveToken] },
+        { ...getEthAccount(), subAccounts: [aaveToken] },
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        aaveToken,
+        aaveAccounts,
+        new Map([[aaveAccounts[0].id, true]]),
+      );
+
+      expect(results).toHaveLength(4);
+    });
+  });
+});

package/src/utils/composeHooks.ts

@@ -0,0 +1,26 @@
+/**
+ *
+ * @param hooks - An array of functions that take an array of items of type T and return an array of items of type U or undefined.
+ * @template T - The type of the items in the input array.
+ * @template U - The type of the items in the output array.
+ * @description This function composes multiple hooks into a single hook that processes an array of items of type T and returns an array of items of type T & U.
+ * @returns  A function that takes an array of items of type T and returns an array of items of type T & U.
+ *
+ */
+
+export function composeHooks<T, U>(
+  ...hooks: Array<(items: T[]) => U[] | undefined>
+): (items: T[]) => (T & U)[] {
+  return (items: T[]): (T & U)[] => {
+    return hooks.reduce<(T & U)[]>(
+      (acc, hook) => {
+        const result = hook?.(acc as T[]) ?? [];
+        return acc.map((item, i) => ({
+          ...item,
+          ...result[i],
+        }));
+      },
+      items as (T & U)[],
+    );
+  };
+}