@ledgerhq/live-common 34.54.0-nightly.20251206023719 → 34.54.0-nightly.20251209140356

package/src/domain/getTotalStakeableAssets.test.ts

@@ -0,0 +1,267 @@
+import { genAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
+import { getCryptoCurrencyById } from "../currencies/index";
+import { Account } from "@ledgerhq/types-live";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import BigNumber from "bignumber.js";
+import { getTotalStakeableAssets } from "./getTotalStakeableAssets";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
+
+// Setup mock store for unit tests
+setupMockCryptoAssetsStore();
+
+const ETH = getCryptoCurrencyById("ethereum");
+const BTC = getCryptoCurrencyById("bitcoin");
+
+// Create mock tokens for tests
+const ZRX_TOKEN: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/0x_project",
+  contractAddress: "0xE41d2489571d322189246DaFA5ebDe1F4699F498",
+  parentCurrency: ETH,
+  tokenType: "erc20",
+  name: "0x Project",
+  ticker: "ZRX",
+  delisted: false,
+  disableCountervalue: false,
+  units: [{ name: "ZRX", code: "ZRX", magnitude: 18 }],
+};
+
+const REP_TOKEN: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/augur",
+  contractAddress: "0x1985365e9f78359a9B6AD760e32412f4a445E862",
+  parentCurrency: ETH,
+  tokenType: "erc20",
+  name: "Augur",
+  ticker: "REP",
+  delisted: false,
+  disableCountervalue: false,
+  units: [{ name: "REP", code: "REP", magnitude: 18 }],
+};
+
+const mockedAccounts: Account[] = [
+  genAccount("mocked-account-1", {
+    currency: ETH,
+    tokensData: [ZRX_TOKEN, REP_TOKEN],
+  }),
+];
+
+describe("getTotalStakeableAssets", () => {
+  it("should return empty Set if no accounts", () => {
+    const result = getTotalStakeableAssets([], [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return empty Set if accounts is null", () => {
+    const result = getTotalStakeableAssets(null, [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return empty Set if accounts is undefined", () => {
+    const result = getTotalStakeableAssets(undefined, [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return empty Set if no staking currencies enabled", () => {
+    const result = getTotalStakeableAssets(mockedAccounts, [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return Set with matching currency ID when staking currency is enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id]; // "ethereum"
+
+    expect(account.balance).toBeTruthy();
+    expect(account.balance instanceof BigNumber).toBe(true);
+    expect(account.balance.gt(0)).toBe(true);
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual({
+      ticker: ETH.ticker,
+      networkName: ETH.name,
+      id: ETH.id,
+    });
+  });
+
+  it("should return Set with matching token IDs when staking tokens are enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ZRX_TOKEN.id, REP_TOKEN.id];
+
+    expect(account.subAccounts).toBeDefined();
+    expect(account.subAccounts?.length).toBe(2);
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(2);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(2);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+        expect.objectContaining({ id: REP_TOKEN.id, ticker: REP_TOKEN.ticker }),
+      ]),
+    );
+  });
+
+  it("should return Set with both currency and token IDs when both are enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id, ZRX_TOKEN.id, REP_TOKEN.id];
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(3);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(3);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
+        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+        expect.objectContaining({ id: REP_TOKEN.id, ticker: REP_TOKEN.ticker }),
+      ]),
+    );
+  });
+
+  it("should filter out currencies without funds", () => {
+    const account = mockedAccounts[0];
+    const accountWithZeroBalance = { ...account, balance: new BigNumber(0) };
+    const stakingCurrenciesEnabled = [ETH.id];
+
+    const result = getTotalStakeableAssets([accountWithZeroBalance], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should filter out tokens without funds", () => {
+    const account = mockedAccounts[0];
+    const [zrxAccount, repAccount] = account.subAccounts || [];
+    const emptyRepAccount = { ...repAccount, balance: new BigNumber(0) };
+    const accountWithEmptyToken = { ...account, subAccounts: [zrxAccount, emptyRepAccount] };
+    const stakingCurrenciesEnabled = [ZRX_TOKEN.id, REP_TOKEN.id];
+
+    const result = getTotalStakeableAssets([accountWithEmptyToken], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(false);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual(
+      expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+    );
+  });
+
+  it("should include partner staking currencies enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id];
+    const partnerStakingCurrenciesEnabled = [ZRX_TOKEN.id];
+
+    const result = getTotalStakeableAssets(
+      [account],
+      stakingCurrenciesEnabled,
+      partnerStakingCurrenciesEnabled,
+    );
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(2);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(2);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
+        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+      ]),
+    );
+  });
+
+  it("should deduplicate IDs when same currency appears in both lists", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id];
+    const partnerStakingCurrenciesEnabled = [ETH.id]; // Same currency
+
+    const result = getTotalStakeableAssets(
+      [account],
+      stakingCurrenciesEnabled,
+      partnerStakingCurrenciesEnabled,
+    );
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual({
+      ticker: ETH.ticker,
+      networkName: ETH.name,
+      id: ETH.id,
+    });
+  });
+
+  it("should handle multiple accounts with different currencies", () => {
+    const ethAccount = mockedAccounts[0];
+    const btcAccount = genAccount("mocked-account-2", {
+      currency: BTC,
+    });
+    const accounts = [ethAccount, btcAccount];
+    const stakingCurrenciesEnabled = [ETH.id, BTC.id];
+
+    const result = getTotalStakeableAssets(accounts, stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(2);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.combinedIds.has(BTC.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(2);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
+        expect.objectContaining({ id: BTC.id, ticker: BTC.ticker }),
+      ]),
+    );
+  });
+
+  it("should only include IDs that match staking currencies enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ZRX_TOKEN.id]; // Only ZRX enabled, not ETH or REP
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(ETH.id)).toBe(false);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(false);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual(
+      expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+    );
+  });
+
+  it("should handle empty arrays for staking currencies", () => {
+    const account = mockedAccounts[0];
+    const result = getTotalStakeableAssets([account], [], []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+});

package/src/domain/getTotalStakeableAssets.ts

@@ -0,0 +1,47 @@
+import { getTokensWithFundsMap } from "./getTokensWithFunds";
+import { Account } from "@ledgerhq/types-live";
+
+export function getTotalStakeableAssets(
+  accounts: Account[] | null | undefined,
+  stakingCurrenciesEnabled: string[],
+  partnerStakingCurrenciesEnabled: string[],
+): {
+  combinedIds: Set<string>;
+  stakeableAssets: { ticker: string; networkName: string; id: string }[];
+} {
+  if (!accounts) return { combinedIds: new Set<string>(), stakeableAssets: [] };
+
+  const accountsWithFundsCurrencies = accounts
+    .filter(account => account?.balance.isGreaterThan(0))
+    .map(account => account?.currency);
+
+  const allStakingCurrenciesEnabled = new Set([
+    ...stakingCurrenciesEnabled,
+    ...partnerStakingCurrenciesEnabled,
+  ]);
+
+  const tokenWithFundsMap = getTokensWithFundsMap(accounts);
+  const filteredAccountCurrencyIds = [...accountsWithFundsCurrencies].filter(currency =>
+    allStakingCurrenciesEnabled.has(currency.id),
+  );
+  const filteredTokenWithFunds = [...tokenWithFundsMap.values()].filter(token =>
+    allStakingCurrenciesEnabled.has(token.id),
+  );
+
+  const combined = new Map<string, { ticker: string; networkName: string; id: string }>();
+  for (const currency of filteredAccountCurrencyIds) {
+    combined.set(currency.id, {
+      ticker: currency.ticker,
+      networkName: currency.name,
+      id: currency.id,
+    });
+  }
+  for (const token of filteredTokenWithFunds) {
+    combined.set(token.id, token);
+  }
+
+  return {
+    combinedIds: new Set(Array.from(combined.values(), details => details.id)),
+    stakeableAssets: Array.from(combined.values()),
+  };
+}

package/src/exchange/swap/api/v5/fetchCurrencyFrom.ts

@@ -45,7 +45,7 @@ export async function fetchCurrencyFrom({
       ...(headers !== undefined ? { headers } : {}),
     });
     return flattenV5CurrenciesToAndFrom(data);
-  } catch (e) {
+  } catch {
     throw Error("Something went wrong in fetchCurrencyFrom call");
   }
 }

package/src/exchange/swap/getIncompatibleCurrencyKeys.ts

@@ -83,6 +83,10 @@ const INCOMPATIBLE_NANO_S_CURRENCY_KEYS: Keys = {
     title: "swap.incompatibility.celo_title",
     description: "swap.incompatibility.celo_description",
   },
+  monad: {
+    title: "swap.incompatibility.monad_title",
+    description: "swap.incompatibility.monad_description",
+  },
 };
 
 export const getIncompatibleCurrencyKeys = (exchange: ExchangeSwap) => {

package/src/exchange/swap/transactionStrategies.ts

@@ -2,6 +2,7 @@ import { BigNumber } from "bignumber.js";
 
 import { Transaction } from "../../generated/types";
 import { TransactionCommon } from "@ledgerhq/types-live";
+import { createStepError, StepError, CustomErrorType } from "../../wallet-api/Exchange";
 export type { SwapLiveError } from "@ledgerhq/wallet-api-exchange-module";
 
 export function defaultTransaction({
@@ -85,11 +86,11 @@ export function stellarTransaction({
   customErrorType,
 }: TransactionWithCustomFee): Extract<Transaction, { family: "stellar" }> {
   if (!payinExtraId)
-    throw {
+    throw createStepError({
       error: new Error("Missing payinExtraId"),
-      step: "PayinExtraIdStepError",
+      step: StepError.PAYIN_EXTRA_ID,
       customErrorType,
-    };
+    });
 
   return {
     family: "stellar",
@@ -110,11 +111,11 @@ export function rippleTransaction({
   customErrorType,
 }: TransactionWithCustomFee): Partial<Extract<Transaction, { family: "xrp" }>> {
   if (!payinExtraId)
-    throw {
+    throw createStepError({
       error: new Error("Missing payinExtraId"),
-      step: "PayinExtraIdStepError",
+      step: StepError.PAYIN_EXTRA_ID,
       customErrorType,
-    };
+    });
 
   return {
     family: "xrp",
@@ -257,7 +258,7 @@ export type TransactionWithCustomFee = TransactionCommon & {
     [key: string]: BigNumber;
   };
   payinExtraId?: string;
-  customErrorType?: "swap";
+  customErrorType?: CustomErrorType;
   extraTransactionParameters?: string;
   family: string;
   sponsored?: boolean;

package/src/featureFlags/defaultFeatures.ts

@@ -110,6 +110,8 @@ export const CURRENCY_DEFAULT_FEATURES = {
   currencyMonadTestnet: DEFAULT_FEATURE,
   currencySomnia: DEFAULT_FEATURE,
   currencyZeroGravity: DEFAULT_FEATURE,
+  currencyConcordium: DEFAULT_FEATURE,
+  currencyConcordiumTestnet: DEFAULT_FEATURE,
 };
 
 /**
@@ -735,6 +737,7 @@ export const DEFAULT_FEATURES: Features = {
   zcashShielded: DEFAULT_FEATURE,
   llmNanoOnboardingFundWallet: DEFAULT_FEATURE,
   lldRebornABtest: DEFAULT_FEATURE,
+  llmRebornABtest: DEFAULT_FEATURE,
 };
 
 // Firebase SDK treat JSON values as strings

package/src/featureFlags/firebaseFeatureFlags.ts

@@ -59,7 +59,7 @@ export const isFeature = (key: string): boolean => {
       return false;
     }
     return true;
-  } catch (error) {
+  } catch {
     console.error(`Failed to check if feature "${key}" exists`);
     return false;
   }

package/src/featureFlags/useHasOverriddenFeatureFlags.ts

@@ -15,7 +15,7 @@ export function useHasLocallyOverriddenFeatureFlags(): boolean {
         try {
           const val = getFeature(featureId as FeatureId);
           return val?.overridesRemote || val?.overriddenByEnv;
-        } catch (e) {
+        } catch {
           return false;
         }
       }),

package/src/hw/getBitcoinLikeInfo.ts

@@ -26,7 +26,7 @@ const getBitcoinLikeInfo = (
         message,
         short,
       };
-    } catch (e) {
+    } catch {
       // in such case, we are in an old firmware we no longer support
       return null;
     }

package/src/mock/account.ts

@@ -199,7 +199,7 @@ export function genAccount(id: number | string, opts: GenAccountOptions = {}): A
             if (initAccount) {
               initAccount(account);
             }
-          } catch (e: any) {
+          } catch {
             // to fix /src/__tests__/cross.ts, skip bridge error if there is no bridge in such currency
           }
         }

package/src/modularDrawer/hooks/useCurrenciesUnderFeatureFlag.ts

@@ -83,6 +83,8 @@ export function useCurrenciesUnderFeatureFlag() {
   const monadTestnet = useFeature("currencyMonadTestnet");
   const somnia = useFeature("currencySomnia");
   const zeroGravity = useFeature("currencyZeroGravity");
+  const concordium = useFeature("currencyConcordium");
+  const concordiumTestnet = useFeature("currencyConcordiumTestnet");
 
   const featureFlaggedCurrencies = useMemo(
     (): Partial<Record<CryptoCurrencyId, Feature<unknown> | null>> => ({
@@ -162,6 +164,8 @@ export function useCurrenciesUnderFeatureFlag() {
       monad_testnet: monadTestnet,
       somnia,
       zero_gravity: zeroGravity,
+      concordium,
+      concordium_testnet: concordiumTestnet,
     }),
     [
       aptos,
@@ -240,6 +244,8 @@ export function useCurrenciesUnderFeatureFlag() {
       monadTestnet,
       somnia,
       zeroGravity,
+      concordium,
+      concordiumTestnet,
     ],
   );
 

package/src/wallet-api/Exchange/SwapError.test.ts

@@ -0,0 +1,126 @@
+/* eslint-env jest */
+import {
+  IgnoredSignatureStepError,
+  ListAccountError,
+  ListCurrencyError,
+  NonceStepError,
+  NotEnoughFunds,
+  PayloadStepError,
+  PayinExtraIdError,
+  SignatureStepError,
+  SwapError,
+  UnknownAccountError,
+} from "./SwapError";
+
+describe("SwapError", () => {
+  it("captures nested error metadata", () => {
+    const nested = new Error("payload failed");
+    Object.assign(nested, { code: "E500" });
+
+    const error = new SwapError("swap999", nested);
+
+    expect(error).toBeInstanceOf(SwapError);
+    expect(error.cause.swapCode).toBe("swap999");
+    expect(error.cause.message).toBe(String(nested));
+    expect(error.cause.code).toBe("E500");
+    expect(error.message).toBe("payload failed");
+  });
+
+  it("defaults to swap000 when no code provided", () => {
+    const error = new SwapError();
+
+    expect(error.cause.swapCode).toBe("swap000");
+    expect(error.message).toBe("undefined");
+  });
+});
+
+type DerivedErrorCase = {
+  label: string;
+  create: (nested?: Error) => SwapError;
+  swapCode: string;
+  name: string;
+  propagatesMessage?: boolean;
+};
+
+const DERIVED_ERROR_CASES: DerivedErrorCase[] = [
+  {
+    label: "NonceStepError",
+    create: nested => new NonceStepError(nested),
+    swapCode: "swap001",
+    name: "NonceStepError",
+    propagatesMessage: true,
+  },
+  {
+    label: "PayloadStepError",
+    create: nested => new PayloadStepError(nested),
+    swapCode: "swap002",
+    name: "PayloadStepError",
+    propagatesMessage: true,
+  },
+  {
+    label: "SignatureStepError",
+    create: nested => new SignatureStepError(nested),
+    swapCode: "swap003",
+    name: "SignatureStepError",
+    propagatesMessage: true,
+  },
+  {
+    label: "IgnoredSignatureStepError",
+    create: nested => new IgnoredSignatureStepError(nested),
+    swapCode: "swap003Ignored",
+    name: "SignatureStepError",
+    propagatesMessage: true,
+  },
+  {
+    label: "NotEnoughFunds",
+    create: () => new NotEnoughFunds(),
+    swapCode: "swap004",
+    name: "NotEnoughFunds",
+  },
+  {
+    label: "ListAccountError",
+    create: nested => new ListAccountError(nested),
+    swapCode: "swap005",
+    name: "ListAccountError",
+    propagatesMessage: true,
+  },
+  {
+    label: "ListCurrencyError",
+    create: nested => new ListCurrencyError(nested),
+    swapCode: "swap006",
+    name: "ListCurrencyError",
+    propagatesMessage: true,
+  },
+  {
+    label: "UnknownAccountError",
+    create: nested => new UnknownAccountError(nested),
+    swapCode: "swap007",
+    name: "UnknownAccountError",
+    propagatesMessage: true,
+  },
+  {
+    label: "PayinExtraIdError",
+    create: nested => new PayinExtraIdError(nested),
+    swapCode: "swap010",
+    name: "PayinExtraIdError",
+    propagatesMessage: true,
+  },
+];
+
+describe.each(DERIVED_ERROR_CASES)(
+  "Derived $label",
+  ({ create, swapCode, name, propagatesMessage }) => {
+    it("inherits SwapError defaults", () => {
+      const nested = new Error("step failure");
+      const error = create(propagatesMessage ? nested : undefined);
+
+      expect(error).toBeInstanceOf(SwapError);
+      expect(error.name).toBe(name);
+      expect(error.cause.swapCode).toBe(swapCode);
+
+      if (propagatesMessage) {
+        expect(error.message).toBe("step failure");
+      }
+    });
+  },
+);