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

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)[],
+    );
+  };
+}

package/src/utils/getAccountTuplesForCurrency.ts

@@ -0,0 +1,34 @@
+import type { Account, TokenAccount } from "@ledgerhq/types-live";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { makeEmptyTokenAccount } from "@ledgerhq/coin-framework/account/helpers";
+
+export type AccountTuple = {
+  account: Account;
+  subAccount: TokenAccount | null;
+};
+
+export function getAccountTuplesForCurrency(
+  currency: CryptoCurrency | TokenCurrency,
+  allAccounts: Account[],
+  accountIds?: Map<string, boolean>,
+): AccountTuple[] {
+  const isToken = currency.type === "TokenCurrency";
+  const targetCurrencyId = isToken ? currency.parentCurrency.id : currency.id;
+
+  return allAccounts
+    .filter(
+      account =>
+        account.currency.id === targetCurrencyId &&
+        (isToken ? true : accountIds ? accountIds.has(account.id) : true),
+    )
+    .map(account => {
+      const subAccount = isToken
+        ? account.subAccounts?.find(
+            (subAcc): subAcc is TokenAccount =>
+              subAcc.type === "TokenAccount" && subAcc.token.id === currency.id,
+          ) || makeEmptyTokenAccount(account, currency)
+        : null;
+
+      return { account, subAccount };
+    });
+}

package/src/wallet-api/Exchange/server.ts

@@ -51,6 +51,7 @@ import { getSwapStepFromError } from "../../exchange/error";
 import { postSwapCancelled } from "../../exchange/swap";
 import { DeviceModelId } from "@ledgerhq/types-devices";
 import { setBroadcastTransaction } from "../../exchange/swap/setBroadcastTransaction";
+import { FAMILIES_MAPPING_LL_TO_WAPI } from "../constants";
 
 export { ExchangeType };
 
@@ -485,7 +486,9 @@ export const handlers = ({
       });
 
       const mainFromAccount = getMainAccount(fromAccount, fromParentAccount);
-      const mainFromAccountFamily = mainFromAccount.currency.family;
+      const mainFromAccountFamily =
+        FAMILIES_MAPPING_LL_TO_WAPI[mainFromAccount.currency.family] ||
+        mainFromAccount.currency.family;
 
       if (transaction.family !== mainFromAccountFamily) {
         return Promise.reject(
@@ -741,9 +744,7 @@ async function getStrategy(
   customErrorType?: any,
 ): Promise<Transaction> {
   const family =
-    currency.type === "TokenCurrency"
-      ? (currency.parentCurrency?.family as Transaction["family"])
-      : (currency.family as Transaction["family"]);
+    currency.type === "TokenCurrency" ? currency.parentCurrency?.family : currency.family;
 
   if (!family) {
     throw new Error(`TokenCurrency missing parentCurrency family: ${currency.id}`);
@@ -755,7 +756,7 @@ async function getStrategy(
   }
 
   // Normalize family key for strategy lookup
-  const familyKey = family === "evm" ? "ethereum" : family;
+  const familyKey = FAMILIES_MAPPING_LL_TO_WAPI[family] || family;
   const strategy = transactionStrategy?.[familyKey];
 
   if (!strategy) {
@@ -764,7 +765,7 @@ async function getStrategy(
 
   try {
     return await strategy({
-      family,
+      family: familyKey,
       amount,
       recipient,
       customFeeConfig: customFeeConfig || {},