@ledgerhq/live-common 34.47.0-nightly.6 → 34.47.0-nightly.8

package/src/bridge/generic-alpaca/prepareTransaction.ts

@@ -2,27 +2,41 @@ import { Account, AccountBridge, TransactionCommon } from "@ledgerhq/types-live"
 import { getAlpacaApi } from "./alpaca";
 import { transactionToIntent } from "./utils";
 import BigNumber from "bignumber.js";
-import { FeeEstimation } from "@ledgerhq/coin-framework/api/types";
+import { AssetInfo, FeeEstimation } from "@ledgerhq/coin-framework/api/types";
+import { decodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
 function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
   return !a && !b ? true : !a || !b ? false : a.eq(b);
 }
 
+type TransactionParam = TransactionCommon & {
+  fees: BigNumber | null | undefined;
+  customFees?: FeeEstimation;
+  assetReference?: string;
+  assetOwner?: string;
+  subAccountId?: string;
+};
+
+function assetInfosFallback(transaction: TransactionParam): {
+  assetReference: string;
+  assetOwner: string;
+} {
+  return {
+    assetReference: transaction.assetReference ?? "",
+    assetOwner: transaction.assetOwner ?? "",
+  };
+}
+
 export function genericPrepareTransaction(
   network: string,
   kind,
 ): AccountBridge<TransactionCommon, Account, any, any>["prepareTransaction"] {
-  return async (
-    account,
-    transaction: TransactionCommon & {
-      fees: BigNumber | null | undefined;
-      customFees?: FeeEstimation;
-      assetReference?: string;
-      assetOwner?: string;
-      subAccountId?: string;
-    },
-  ) => {
-    const [assetReference, assetOwner] = getAssetInfos(transaction);
+  return async (account, transaction: TransactionParam) => {
+    const { getAssetFromToken } = getAlpacaApi(network, kind);
+    const { assetReference, assetOwner } = getAssetFromToken
+      ? getAssetInfos(transaction, account.freshAddress, getAssetFromToken)
+      : assetInfosFallback(transaction);
 
     let fees = transaction.customFees?.parameters?.fees || null;
     if (fees === null) {
@@ -54,11 +68,24 @@ export function genericPrepareTransaction(
 }
 
 export function getAssetInfos(
-  tr: TransactionCommon & { assetReference?: string; assetOwner?: string },
-): string[] {
+  tr: TransactionParam,
+  owner: string,
+  getAssetFromToken: (token: TokenCurrency, owner: string) => AssetInfo,
+): {
+  assetReference: string;
+  assetOwner: string;
+} {
   if (tr.subAccountId) {
-    const assetString = tr.subAccountId.split("+")[1];
-    return assetString.split(":");
+    const { token } = decodeTokenAccountId(tr.subAccountId);
+
+    if (!token) return assetInfosFallback(tr);
+
+    const asset = getAssetFromToken(token, owner);
+
+    return {
+      assetOwner: ("assetOwner" in asset && asset.assetOwner) || "",
+      assetReference: ("assetReference" in asset && asset.assetReference) || "",
+    };
   }
-  return [tr.assetReference || "", tr.assetOwner || ""];
+  return assetInfosFallback(tr);
 }

package/src/bridge/generic-alpaca/utils.test.ts

@@ -43,6 +43,46 @@ describe("Alpaca utils", () => {
       recipients: ["recipient1"],
     };
 
+    it("does not include fees in non native asset value", () => {
+      expect(
+        adaptCoreOperationToLiveOperation("account", {
+          id: "operation",
+          asset: { type: "token", assetOwner: "owner", assetReference: "reference" },
+          type: "OUT",
+          value: BigInt(100),
+          tx: {
+            hash: "hash",
+            fees: BigInt(10),
+            block: {
+              hash: "block_hash",
+              height: 123456,
+            },
+            date: new Date("2025-08-29T12:00:00Z"),
+          },
+          senders: ["sender"],
+          recipients: ["recipient"],
+        }),
+      ).toEqual({
+        id: "account-hash-OUT",
+        hash: "hash",
+        accountId: "account",
+        type: "OUT",
+        value: new BigNumber(100), // value only
+        fee: new BigNumber(10),
+        extra: {
+          assetOwner: "owner",
+          assetReference: "reference",
+        },
+        blockHash: "block_hash",
+        blockHeight: 123456,
+        senders: ["sender"],
+        recipients: ["recipient"],
+        date: new Date("2025-08-29T12:00:00Z"),
+        transactionSequenceNumber: undefined,
+        hasFailed: false,
+      });
+    });
+
     it("adapts a basic OUT operation", () => {
       const result = adaptCoreOperationToLiveOperation(accountId, baseOp);
 

package/src/bridge/generic-alpaca/utils.ts

@@ -46,15 +46,14 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
   }
   const bnFees = new BigNumber(op.tx.fees.toString());
   const res = {
-    id: extra.ledgerOpType
-      ? encodeOperationId(accountId, op.tx.hash, extra.ledgerOpType)
-      : encodeOperationId(accountId, op.tx.hash, op.type),
+    id: encodeOperationId(accountId, op.tx.hash, op.type),
     hash: op.tx.hash,
     accountId,
     type: opType,
-    value: ["OUT", "FEES"].includes(opType)
-      ? new BigNumber(op.value.toString()).plus(bnFees)
-      : new BigNumber(op.value.toString()),
+    value:
+      op.asset.type === "native" && ["OUT", "FEES"].includes(opType)
+        ? new BigNumber(op.value.toString()).plus(bnFees)
+        : new BigNumber(op.value.toString()),
     fee: bnFees,
     blockHash: op.tx.block.hash,
     blockHeight: op.tx.block.height,

package/src/e2e/enum/DeviceLabels.ts

@@ -55,4 +55,5 @@ export enum DeviceLabels {
   VERIFY_POLYGON = "Verify Polygon",
   VERIFY_SOLANA_ADDRESS = "Verify Solana address",
   REVIEW_TRANSACTION = "Review transaction",
+  I_UNDERSTAND = "I understand",
 }

package/src/e2e/speculos.ts

@@ -460,7 +460,7 @@ async function retryAxiosRequest<T>(
   throw lastError!;
 }
 
-export async function waitFor(text: string, maxAttempts = 15): Promise<string[]> {
+export async function waitFor(text: string, maxAttempts = 60): Promise<string[]> {
   const port = getEnv("SPECULOS_API_PORT");
   const address = getSpeculosAddress();
   const url = `${address}:${port}/events?stream=false&currentscreenonly=true`;
@@ -737,6 +737,14 @@ export async function verifyAmountsAndAcceptSwap(swap: Swap, amount: string) {
   await pressBoth();
 }
 
+export async function verifyAmountsAndAcceptSwapForDifferentSeed(swap: Swap, amount: string) {
+  await pressUntilTextFound(DeviceLabels.I_UNDERSTAND);
+  await pressBoth();
+  const events = await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
+  await verifySwapData(swap, events, amount);
+  await pressBoth();
+}
+
 export async function verifyAmountsAndRejectSwap(swap: Swap, amount: string) {
   await waitFor(DeviceLabels.REVIEW_TRANSACTION);
   const events = await pressUntilTextFound(DeviceLabels.REJECT);

package/src/featureFlags/defaultFeatures.ts

@@ -625,7 +625,6 @@ export const DEFAULT_FEATURES: Features = {
       enableModularization: false,
     },
   },
-  lldModularDrawerBackendData: DEFAULT_FEATURE,
   llmModularDrawer: {
     ...DEFAULT_FEATURE,
     params: {

package/src/modularDrawer/hooks/modules/useLeftApyModule.tsx

@@ -1,8 +1,8 @@
 import React, { useMemo } from "react";
 import { useSelector } from "react-redux";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { ApyType } from "../../types";
 import { selectInterestRateByCurrency } from "../../data/entities/interestRateSelectors";
+import { ApyType } from "../../utils/type";
 
 const isValidApyType = (type: string): type is ApyType =>
   type === "NRR" || type === "APY" || type === "APR";

package/src/modularDrawer/hooks/{modules/useAssetAccountCounts.tsx → useAssetAccountCounts.tsx}

@@ -1,8 +1,8 @@
 import { Observable } from "rxjs";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { getAccountTuplesForCurrency } from "../../../utils/getAccountTuplesForCurrency";
+import { getAccountTuplesForCurrency } from "../../utils/getAccountTuplesForCurrency";
 import type { Account } from "@ledgerhq/types-live";
-import { WalletAPIAccount } from "../../../wallet-api/types";
+import { WalletAPIAccount } from "../../wallet-api/types";
 
 type AccountModuleParams = {
   assets: CryptoOrTokenCurrency[];

package/src/modularDrawer/hooks/useLeftAccounts.tsx

@@ -0,0 +1,23 @@
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { ReactNode } from "react";
+import { AccountModuleParams, AccountDataItem } from "../utils/type";
+
+export const createUseLeftAccountsModule = ({
+  useAccountData,
+  accountsCount,
+}: {
+  useAccountData: (params: AccountModuleParams) => AccountDataItem[];
+  accountsCount: (args: { label: string }) => ReactNode;
+}) => {
+  return function useLeftAccountsModule(
+    params: AccountModuleParams,
+  ): Array<CryptoOrTokenCurrency & { leftElement?: ReactNode; count: number }> {
+    const accountData = useAccountData(params);
+
+    return accountData.map(({ asset, label, count }) => ({
+      ...asset,
+      leftElement: count > 0 ? accountsCount({ label }) : undefined,
+      count,
+    }));
+  };
+};

package/src/modularDrawer/hooks/useLeftAccountsApy.tsx

@@ -0,0 +1,28 @@
+import {
+  AccountDataItem,
+  AccountModuleParams,
+  CreateAccountsCountAndApy,
+  NetworkWithCount,
+} from "../utils/type";
+
+export const createUseLeftAccountsApyModule = ({
+  useAccountData,
+  accountsCountAndApy,
+}: {
+  useAccountData: (params: AccountModuleParams) => AccountDataItem[];
+  accountsCountAndApy: CreateAccountsCountAndApy;
+}) => {
+  return function useLeftAccountsApyModule(params: AccountModuleParams): NetworkWithCount[] {
+    const accountData = useAccountData(params);
+
+    return accountData.map(({ asset, label, count }) => {
+      const value = 5.11; // TODO to be retrieved from DADA
+      const type = "APY"; // TODO to be retrieved from DADA
+      return {
+        ...asset,
+        leftElement: count > 0 ? accountsCountAndApy({ label, value, type }) : undefined,
+        count,
+      };
+    });
+  };
+};

package/src/modularDrawer/hooks/useLeftApy.tsx

@@ -0,0 +1,19 @@
+import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { ReactNode } from "react";
+import { ApyType } from "../utils/type";
+
+export const createUseLeftApyModule = ({
+  ApyIndicator,
+}: {
+  ApyIndicator: (args: { value: number; type: ApyType }) => ReactNode;
+}) => {
+  return (assets: CryptoOrTokenCurrency[]) => {
+    const value = 5.11; // TODO: fetch DADA
+    const type: ApyType = "APY"; // TODO: fetch DADA
+
+    return assets.map(asset => ({
+      ...asset,
+      leftElement: ApyIndicator({ value, type }),
+    }));
+  };
+};

package/src/modularDrawer/hooks/useRightBalanceAsset.tsx

@@ -0,0 +1,140 @@
+import { useMemo } from "react";
+import type { ReactNode } from "react";
+import type { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
+import BigNumber from "bignumber.js";
+import { counterValueFormatter } from "../utils/counterValueFormatter";
+import { compareByBalanceThenFiat } from "../utils/sortByBalance";
+import { UseBalanceDeps } from "../utils/type";
+import { buildProviderCurrenciesMap } from "../utils/buildProviderCurrenciesMap";
+import { CurrenciesByProviderId } from "../../deposit/type";
+import { calculateProviderTotals } from "../utils/calculateProviderTotal";
+import { getProviderCurrency } from "../utils/getProviderCurrency";
+import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
+import { groupAccountsByAsset } from "../utils/groupAccountsByAsset";
+
+export type AssetDeps = {
+  useBalanceDeps: UseBalanceDeps;
+  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
+};
+
+export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem }: AssetDeps) {
+  const formatProviderResult = (
+    providerCurrency: CryptoOrTokenCurrency,
+    totalBalance: BigNumber,
+    totalFiatValue: BigNumber,
+    counterValueCurrency: Currency,
+    locale: string,
+    discreet: boolean,
+  ) => {
+    const unit = providerCurrency.units?.[0];
+    const balance = unit
+      ? formatCurrencyUnit(unit, totalBalance, { showCode: true, discreet })
+      : `${totalBalance.toFixed()} ${providerCurrency.ticker ?? providerCurrency.symbol}`;
+    const fiatValue = counterValueFormatter({
+      currency: counterValueCurrency.ticker,
+      value: totalFiatValue.toNumber(),
+      locale,
+      allowZeroValue: true,
+    });
+    return { balance, fiatValue };
+  };
+
+  return function useRightBalanceAsset(
+    assets: CryptoOrTokenCurrency[],
+    currenciesByProvider: CurrenciesByProviderId[],
+  ) {
+    const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
+
+    const grouped = useMemo(
+      () => groupAccountsByAsset(flattenedAccounts, state, counterValueCurrency, discreet),
+      [flattenedAccounts, state, counterValueCurrency, discreet],
+    );
+
+    const providerMap = useMemo(
+      () => buildProviderCurrenciesMap(currenciesByProvider),
+      [currenciesByProvider],
+    );
+
+    return useMemo(() => {
+      if (!providerMap) {
+        const allBalance = getBalanceAndFiatValueByAssets(
+          flattenedAccounts,
+          assets,
+          state,
+          counterValueCurrency,
+          discreet,
+          locale,
+        );
+        const balanceMap = new Map(allBalance.map(b => [b.id, b]));
+        const assetsWithBalanceData = assets.map(asset => {
+          const balanceData = balanceMap.get(asset.id) || {};
+          return {
+            asset,
+            balanceData,
+          };
+        });
+
+        assetsWithBalanceData.sort((a, b) =>
+          compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
+        );
+
+        return assetsWithBalanceData.map(({ asset, balanceData }) => ({
+          ...asset,
+          rightElement: balanceItem(balanceData),
+        }));
+      }
+
+      const assetsSet = new Set(assets.map(a => a.id));
+      const providerResultsMap = new Map<string, { balance?: string; fiatValue?: string }>();
+
+      for (const [, { currencies, mainCurrency }] of providerMap) {
+        if (!assetsSet.has(mainCurrency.id)) continue;
+        const providerCurrency = getProviderCurrency(mainCurrency, currencies);
+        if (!providerCurrency) continue;
+
+        const { totalBalance, totalFiatValue, hasAccounts } = calculateProviderTotals(
+          currencies,
+          grouped,
+        );
+        if (!hasAccounts) continue;
+
+        const { balance, fiatValue } = formatProviderResult(
+          providerCurrency,
+          totalBalance,
+          totalFiatValue,
+          counterValueCurrency,
+          locale,
+          discreet,
+        );
+        providerResultsMap.set(mainCurrency.id, { balance, fiatValue });
+      }
+
+      const assetsWithBalanceData = assets.map(asset => {
+        const balanceData = providerResultsMap.get(asset.id) || {};
+        return {
+          asset,
+          balanceData,
+        };
+      });
+
+      assetsWithBalanceData.sort((a, b) =>
+        compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
+      );
+
+      return assetsWithBalanceData.map(({ asset, balanceData }) => ({
+        ...asset,
+        rightElement: balanceItem(balanceData),
+      }));
+    }, [
+      assets,
+      providerMap,
+      flattenedAccounts,
+      state,
+      counterValueCurrency,
+      discreet,
+      locale,
+      grouped,
+    ]);
+  };
+}

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -0,0 +1,116 @@
+import { useMemo, type ReactNode } from "react";
+import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { compareByBalanceThenFiat } from "../utils/sortByBalance";
+import { BalanceUI, UseBalanceDeps } from "../utils/type";
+import { CurrenciesByProviderId } from "../../deposit/type";
+import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
+
+export type NetworkDeps = {
+  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
+  useBalanceDeps: UseBalanceDeps;
+};
+
+type Params = {
+  assets: CryptoOrTokenCurrency[];
+  selectedAssetId: string;
+  currenciesByProvider: CurrenciesByProviderId[];
+};
+
+export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: NetworkDeps) {
+  return function useRightBalanceNetwork({
+    assets: networks,
+    selectedAssetId,
+    currenciesByProvider,
+  }: Params) {
+    const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
+
+    return useMemo(() => {
+      if (currenciesByProvider && currenciesByProvider.length > 0) {
+        const providerOfSelectedAsset = currenciesByProvider.find(provider =>
+          provider.currenciesByNetwork.some(currency => currency.id === selectedAssetId),
+        );
+
+        if (providerOfSelectedAsset) {
+          const pairs = networks.map(network => ({
+            network,
+            asset: providerOfSelectedAsset.currenciesByNetwork.find(currency =>
+              currency.type === "TokenCurrency"
+                ? currency.parentCurrency.id === network.id
+                : currency.id === network.id,
+            ),
+          }));
+
+          const validAssets = pairs.filter(p => p.asset).map(p => p.asset!);
+
+          const allBalanceData =
+            validAssets.length > 0
+              ? getBalanceAndFiatValueByAssets(
+                  flattenedAccounts,
+                  validAssets,
+                  state,
+                  counterValueCurrency,
+                  discreet,
+                  locale,
+                )
+              : [];
+
+          const balanceMap = new Map(allBalanceData.map(b => [b.id, b]));
+
+          const networkWithBalanceData = pairs.map(({ network, asset }) => {
+            const balanceData: BalanceUI = asset ? balanceMap.get(asset.id) || {} : {};
+            return {
+              network,
+              balanceData,
+            };
+          });
+
+          networkWithBalanceData.sort((a, b) =>
+            compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
+          );
+
+          return networkWithBalanceData.map(({ network, balanceData }) => ({
+            ...network,
+            rightElement: balanceItem(balanceData),
+          }));
+        }
+      }
+
+      const networkBalanceData = getBalanceAndFiatValueByAssets(
+        flattenedAccounts,
+        networks,
+        state,
+        counterValueCurrency,
+        discreet,
+        locale,
+      );
+
+      const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
+
+      const networksWithBalance = networks.map(network => {
+        const balanceData = balanceMap.get(network.id) || {};
+        return {
+          network,
+          balanceData,
+        };
+      });
+
+      networksWithBalance.sort((a, b) =>
+        compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
+      );
+
+      return networksWithBalance.map(({ network, balanceData }) => ({
+        ...network,
+        rightElement: balanceItem(balanceData),
+      }));
+    }, [
+      networks,
+      selectedAssetId,
+      currenciesByProvider,
+      flattenedAccounts,
+      state,
+      counterValueCurrency,
+      discreet,
+      locale,
+    ]);
+  };
+}

package/src/modularDrawer/modules/createAssetConfiguration.ts

@@ -0,0 +1,61 @@
+import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { AssetType, CreateAssetConfigurationHook, AssetConfigurationDeps } from "../utils/type";
+import { CurrenciesByProviderId } from "../../deposit/type";
+import { composeHooks } from "../../utils/composeHooks";
+import { createUseLeftApyModule } from "../hooks/useLeftApy";
+import { createUseRightBalanceAsset } from "../hooks/useRightBalanceAsset";
+
+const getRightElement =
+  (AssetConfigurationDeps: AssetConfigurationDeps) => (rightElement: string) => {
+    switch (rightElement) {
+      case "balance":
+        return createUseRightBalanceAsset({
+          useBalanceDeps: AssetConfigurationDeps.useBalanceDeps,
+          balanceItem: AssetConfigurationDeps.balanceItem,
+        });
+      case "marketTrend":
+      case "undefined":
+      default:
+        return undefined;
+    }
+  };
+
+const getLeftElement =
+  (AssetConfigurationDeps: AssetConfigurationDeps) => (leftElement: string) => {
+    switch (leftElement) {
+      case "apy":
+        return createUseLeftApyModule({ ApyIndicator: AssetConfigurationDeps.ApyIndicator });
+      case "priceVariation":
+      case "undefined":
+      default:
+        return undefined;
+    }
+  };
+
+const createAssetConfigurationHook: CreateAssetConfigurationHook =
+  deps =>
+  ({ assetsConfiguration, currenciesByProvider }) => {
+    const { rightElement = "undefined", leftElement = "undefined" } = assetsConfiguration ?? {};
+
+    const rightHook = getRightElement(deps)(rightElement);
+    const leftHook = getLeftElement(deps)(leftElement);
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const hooks = [rightHook, leftHook].filter(Boolean) as Array<
+      (
+        assets: CryptoOrTokenCurrency[],
+        currenciesByProvider?: CurrenciesByProviderId[],
+      ) => AssetType[]
+    >;
+
+    return (assets: CryptoOrTokenCurrency[]) => {
+      const composedHook = composeHooks<CryptoOrTokenCurrency, AssetType>(
+        ...hooks.map(
+          hook => (assets: CryptoOrTokenCurrency[]) => hook(assets, currenciesByProvider),
+        ),
+      );
+      return composedHook(assets);
+    };
+  };
+
+export default createAssetConfigurationHook;