@ledgerhq/live-common 34.49.0 → 34.50.0-nightly.0

package/src/families/tezos/react.ts

@@ -1,6 +1,6 @@
 import type { AccountLike } from "@ledgerhq/types-live";
 import { useEffect, useMemo, useState } from "react";
-import { Baker, Delegation } from "@ledgerhq/coin-tezos/types/index";
+import { Baker, Delegation, StakingPosition } from "@ledgerhq/coin-tezos/types/index";
 import { bakers } from "@ledgerhq/coin-tezos/network/index";
 
 export function useBakers(whitelistAddresses: string[]): Baker[] {
@@ -55,3 +55,22 @@ export function useRandomBaker(bakers: Baker[]): Baker {
   }, [bakers.length]);
   return bakers[randomBakerIndex];
 }
+
+export function useStakingPositions(account: AccountLike): StakingPosition[] {
+  const delegation = useDelegation(account);
+
+  return useMemo(() => {
+    if (account.type !== "Account" || !delegation?.address) return [];
+
+    return [
+      {
+        uid: account.freshAddress,
+        address: account.freshAddress,
+        delegate: delegation.address,
+        state: "active" as const,
+        asset: { type: "native" as const },
+        amount: BigInt(account.balance.toString()),
+      },
+    ];
+  }, [account, delegation]);
+}

package/src/families/tezos/setup.ts

@@ -1,24 +1,14 @@
 // Goal of this file is to inject all necessary device/signer dependency to coin-modules
 
 import { DerivationType, LedgerSigner } from "@taquito/ledger-signer";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-import { TezosCoinConfig } from "@ledgerhq/coin-tezos/config";
-import { createBridges } from "@ledgerhq/coin-tezos/bridge/index";
-import type {
-  Transaction,
-  TezosSigner,
-  TransactionStatus,
-  TezosAccount,
-} from "@ledgerhq/coin-tezos/types/index";
+import type { TezosSigner } from "@ledgerhq/coin-tezos/types/index";
 import makeCliTools from "@ledgerhq/coin-tezos/test/cli";
 import type { CliTools } from "@ledgerhq/coin-tezos/test/cli";
 import tezosResolver from "@ledgerhq/coin-tezos/signer/index";
 import Xtz, { Curve } from "@ledgerhq/hw-app-tezos";
 import Transport from "@ledgerhq/hw-transport";
-import type { Bridge } from "@ledgerhq/types-live";
-import { CreateSigner, createResolver, executeWithSigner } from "../../bridge/setup";
+import { createResolver, CreateSigner } from "../../bridge/setup";
 import { Resolver } from "../../hw/getAddress/types";
-import { getCurrencyConfiguration } from "../../config";
 
 const createSigner: CreateSigner<TezosSigner> = (transport: Transport) => {
   const xtz = new Xtz(transport);
@@ -46,17 +36,8 @@ const createSigner: CreateSigner<TezosSigner> = (transport: Transport) => {
   };
 };
 
-const getCurrencyConfig = (): TezosCoinConfig => {
-  return getCurrencyConfiguration(getCryptoCurrencyById("tezos"));
-};
-
-const bridge: Bridge<Transaction, TezosAccount, TransactionStatus> = createBridges(
-  executeWithSigner(createSigner),
-  getCurrencyConfig,
-);
-
 const resolver: Resolver = createResolver(createSigner, tezosResolver);
 
 const cliTools: CliTools = makeCliTools();
 
-export { bridge, cliTools, resolver };
+export { cliTools, resolver };

package/src/families/ton/bridge.integration.test.ts

@@ -2,4 +2,7 @@ import { dataset } from "@ledgerhq/coin-ton/__tests__/integration/bridge.integra
 import { testBridge } from "../../__tests__/test-helpers/bridge";
 import "../../__tests__/test-helpers/setup";
 
-testBridge(dataset);
+// FIXME: Disabled due to TypeError in Send max transaction (ts.amount undefined)
+describe.skip("ton integration", () => {
+  testBridge(dataset);
+});

package/src/featureFlags/defaultFeatures.ts

@@ -97,6 +97,8 @@ export const CURRENCY_DEFAULT_FEATURES = {
   currencyHyperevm: DEFAULT_FEATURE,
   currencyCantonNetwork: DEFAULT_FEATURE,
   currencyKaspa: DEFAULT_FEATURE,
+  currencyEthereumHoodi: DEFAULT_FEATURE,
+  currencyCore: DEFAULT_FEATURE,
 };
 
 /**
@@ -111,6 +113,7 @@ export const DEFAULT_FEATURES: Features = {
   ptxServiceCtaExchangeDrawer: DEFAULT_FEATURE,
   ptxServiceCtaScreens: DEFAULT_FEATURE,
   ptxSwapReceiveTRC20WithoutTrx: DEFAULT_FEATURE,
+  ptxSwapDetailedView: DEFAULT_FEATURE,
   disableNftLedgerMarket: DEFAULT_FEATURE,
   disableNftRaribleOpensea: DEFAULT_FEATURE,
   disableNftSend: DEFAULT_FEATURE,
@@ -669,6 +672,7 @@ export const DEFAULT_FEATURES: Features = {
   },
   supportDeviceApex: DEFAULT_FEATURE,
   llmSyncOnboardingIncr1: DEFAULT_FEATURE,
+  noah: DEFAULT_FEATURE,
 };
 
 // Firebase SDK treat JSON values as strings

package/src/generated/bridge/js.ts

@@ -17,7 +17,6 @@ import { bridge as near } from "../../families/near/setup";
 import { bridge as polkadot } from "../../families/polkadot/setup";
 import { bridge as solana } from "../../families/solana/setup";
 import { bridge as stacks } from "../../families/stacks/setup";
-import { bridge as tezos } from "../../families/tezos/setup";
 import { bridge as ton } from "../../families/ton/setup";
 import { bridge as tron } from "../../families/tron/setup";
 import { bridge as vechain } from "../../families/vechain/setup";
@@ -44,7 +43,6 @@ export default {
   polkadot,
   solana,
   stacks,
-  tezos,
   ton,
   tron,
   vechain,

package/src/modularDrawer/hooks/useRightBalanceAsset.tsx

@@ -10,15 +10,18 @@ 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;
+  assetsMap: Map<
+    string,
+    { mainCurrency: CryptoOrTokenCurrency; currencies: CryptoOrTokenCurrency[] }
+  >;
 };
 
-export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem }: AssetDeps) {
+export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem, assetsMap }: AssetDeps) {
   const formatProviderResult = (
     providerCurrency: CryptoOrTokenCurrency,
     totalBalance: BigNumber,
@@ -58,15 +61,26 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem }: Asse
 
     return useMemo(() => {
       if (!providerMap) {
-        const allBalance = getBalanceAndFiatValueByAssets(
-          flattenedAccounts,
-          assets,
-          state,
-          counterValueCurrency,
-          discreet,
-          locale,
-        );
-        const balanceMap = new Map(allBalance.map(b => [b.id, b]));
+        const balanceMap = new Map();
+
+        for (const [, { currencies, mainCurrency }] of assetsMap) {
+          const { totalBalance, totalFiatValue } = calculateProviderTotals(currencies, grouped);
+
+          const { balance, fiatValue } = formatProviderResult(
+            mainCurrency,
+            totalBalance,
+            totalFiatValue,
+            counterValueCurrency,
+            locale,
+            discreet,
+          );
+
+          balanceMap.set(mainCurrency.id, {
+            balance: balance,
+            fiatValue: fiatValue,
+          });
+        }
+
         const assetsWithBalanceData = assets.map(asset => {
           const balanceData = balanceMap.get(asset.id) || {};
           return {
@@ -126,15 +140,6 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem }: Asse
         ...asset,
         rightElement: balanceItem(balanceData),
       }));
-    }, [
-      assets,
-      providerMap,
-      flattenedAccounts,
-      state,
-      counterValueCurrency,
-      discreet,
-      locale,
-      grouped,
-    ]);
+    }, [providerMap, assets, grouped, counterValueCurrency, locale, discreet]);
   };
 }

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -12,6 +12,7 @@ export type NetworkDeps = {
 
 type Params = {
   assets: CryptoOrTokenCurrency[];
+  networks: CryptoOrTokenCurrency[];
   selectedAssetId: string;
   currenciesByProvider: CurrenciesByProviderId[];
 };
@@ -21,6 +22,7 @@ export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: Ne
     assets: networks,
     selectedAssetId,
     currenciesByProvider,
+    networks: actualNetworks,
   }: Params) {
     const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
 
@@ -77,7 +79,7 @@ export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: Ne
 
       const networkBalanceData = getBalanceAndFiatValueByAssets(
         flattenedAccounts,
-        networks,
+        actualNetworks,
         state,
         counterValueCurrency,
         discreet,
@@ -86,7 +88,7 @@ export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: Ne
 
       const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
 
-      const networksWithBalance = networks.map(network => {
+      const networksWithBalance = actualNetworks.map(network => {
         const balanceData = balanceMap.get(network.id) || {};
         return {
           network,

package/src/modularDrawer/modules/createAssetConfiguration.ts

@@ -24,6 +24,7 @@ const getRightElement =
         return createUseRightBalanceAsset({
           useBalanceDeps: AssetConfigurationDeps.useBalanceDeps,
           balanceItem: AssetConfigurationDeps.balanceItem,
+          assetsMap: AssetConfigurationDeps.assetsMap,
         });
     }
   };

package/src/modularDrawer/utils/groupCurrenciesByProvider.ts

@@ -0,0 +1,27 @@
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { AssetData } from "./type";
+
+export const groupCurrenciesByProvider = (assetsSorted: AssetData[]) => {
+  const assetMap = new Map<
+    string,
+    { mainCurrency: CryptoOrTokenCurrency; currencies: CryptoOrTokenCurrency[] }
+  >();
+
+  if (assetsSorted) {
+    for (const item of assetsSorted) {
+      const {
+        asset: { id: providerId },
+        networks = [],
+      } = item;
+      if (networks.length > 0) {
+        const mainCurrency = networks.find(c => c.id === providerId) ?? networks[0];
+        assetMap.set(providerId, {
+          mainCurrency,
+          currencies: networks,
+        });
+      }
+    }
+  }
+
+  return assetMap;
+};

package/src/modularDrawer/utils/index.ts

@@ -2,6 +2,7 @@ import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { CurrenciesByProviderId } from "../../deposit/type";
 import { haveOneCommonProvider } from "./haveOneCommonProvider";
 import { getBalanceAndFiatValue } from "./getBalanceAndFiatValue";
+import { groupCurrenciesByProvider } from "./groupCurrenciesByProvider";
 
 function isCorrespondingCurrency(
   elem: CryptoOrTokenCurrency,
@@ -33,4 +34,5 @@ export {
   getEffectiveCurrency,
   haveOneCommonProvider,
   getBalanceAndFiatValue,
+  groupCurrenciesByProvider,
 };

package/src/modularDrawer/utils/type.ts

@@ -6,6 +6,8 @@ import { Observable } from "rxjs";
 import { WalletAPIAccount } from "../../wallet-api/types";
 import { CurrenciesByProviderId } from "../../deposit/type";
 import { EnhancedModularDrawerConfiguration } from "../../wallet-api/ModularDrawer/types";
+import { InterestRate } from "../data/entities";
+import { MarketItemResponse } from "../../market/utils/types";
 
 export type ApyType = "NRR" | "APY" | "APR";
 
@@ -115,8 +117,25 @@ export type AssetConfigurationDeps = {
   MarketPriceIndicator: (args: { price: string; percent: number }) => ReactNode;
   useBalanceDeps: UseBalanceDeps;
   balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
+  assetsMap: Map<
+    string,
+    { mainCurrency: CryptoOrTokenCurrency; currencies: CryptoOrTokenCurrency[] }
+  >;
 };
 
 export type CreateAssetConfigurationHook = (
   AssetConfigurationDeps: AssetConfigurationDeps,
 ) => (props: Props) => (assets: CryptoOrTokenCurrency[]) => (CryptoOrTokenCurrency & AssetType)[];
+
+export type AssetData = {
+  asset: {
+    id: string;
+    ticker: string;
+    name: string;
+    assetsIds: Record<string, string>;
+    metaCurrencyId?: string;
+  };
+  networks: CryptoOrTokenCurrency[];
+  interestRates?: InterestRate;
+  market?: Partial<MarketItemResponse>;
+};

package/src/notifications/ServiceStatusProvider/entry-points.ts

@@ -0,0 +1,3 @@
+type EntryPoint = "notifications" | "flow";
+
+export { EntryPoint };

package/src/notifications/ServiceStatusProvider/index.test.ts

@@ -0,0 +1,102 @@
+import { filterServiceStatusIncidents } from "./index";
+import { LEDGER_COMPONENTS } from "./ledger-components";
+import type { Incident } from "./types";
+
+const makeIncident = (overrides: Partial<Incident> = {}): Incident => ({
+  created_at: "2025-01-01T00:00:00Z",
+  id: Math.random().toString(16).slice(2),
+  impact: "minor",
+  incident_updates: [],
+  monitoring_at: null,
+  name: "Test incident",
+  page_id: null,
+  resolved_at: null,
+  shortlink: null,
+  status: "investigating",
+  updated_at: null,
+  ...overrides,
+});
+
+describe("filterServiceStatusIncidents", () => {
+  it("returns empty when no tickers or no incidents", () => {
+    expect(filterServiceStatusIncidents([], ["BTC"]).length).toBe(0);
+    expect(filterServiceStatusIncidents([makeIncident()], []).length).toBe(0);
+  });
+
+  it("matches incidents with known Ledger components (case-insensitive)", () => {
+    const incidents: Incident[] = [
+      makeIncident({ components: [{ id: "1", name: "Ledger Application Store" }] }),
+      makeIncident({ components: [{ id: "2", name: "ledger appliCAtion store" }] }),
+      makeIncident({ components: [{ id: "3", name: "Unknown Component" }] }),
+    ];
+
+    const result = filterServiceStatusIncidents(incidents, ["BTC"], "notifications");
+    expect(result.map(i => i.components?.[0].id)).toEqual(["1", "2"]);
+  });
+
+  it("matches incidents if a component contains a tracked ticker as a whole word (case-insensitive)", () => {
+    const incidents: Incident[] = [
+      makeIncident({ components: [{ id: "1", name: "BTC Node" }] }),
+      makeIncident({ components: [{ id: "2", name: "eth Node" }] }),
+      makeIncident({ components: [{ id: "3", name: "TETHER Service" }] }),
+      makeIncident({ components: [{ id: "4", name: "NOTBTCService" }] }),
+    ];
+
+    const result = filterServiceStatusIncidents(incidents, ["BTC", "ETH"]);
+    expect(result.map(i => i.components?.[0].id)).toEqual(["1", "2"]);
+  });
+
+  it("includes incidents with no components array or empty array", () => {
+    const incidents: Incident[] = [
+      makeIncident({ components: undefined }),
+      makeIncident({ components: [] }),
+    ];
+
+    const result = filterServiceStatusIncidents(incidents, ["BTC"]);
+    expect(result.length).toBe(2);
+  });
+
+  it("escapes tickers so special regex characters do not break matching", () => {
+    const incidents: Incident[] = [
+      makeIncident({ components: [{ id: "1", name: "USDT Node" }] }),
+      makeIncident({ components: [{ id: "2", name: "US.DT Node" }] }),
+      makeIncident({ components: [{ id: "3", name: "(USDT) Node" }] }),
+      makeIncident({ components: [{ id: "4", name: "Ethereum  Node" }] }),
+      makeIncident({ components: [{ id: "5", name: "Ethereum (ETH) swap issue" }] }),
+    ];
+
+    const result = filterServiceStatusIncidents(incidents, ["USDT", "ETH"]);
+    expect(result.map(i => i.components?.[0].id)).toEqual(["1", "3", "5"]);
+    expect(result.length).toBe(3);
+  });
+
+  it("matches incidents for all known Ledger components", () => {
+    const incidents: Incident[] = LEDGER_COMPONENTS.map((name, index) =>
+      makeIncident({ components: [{ id: `${index + 1}`, name }] }),
+    );
+
+    const result = filterServiceStatusIncidents(incidents, ["BTC"], "notifications");
+    expect(result.length).toBe(LEDGER_COMPONENTS.length);
+  });
+
+  it("filters correctly with common tickers", () => {
+    const tickers = ["XRP", "SOL", "ETH", "BTC", "ADA", "USDC", "USDT"];
+    const incidents: Incident[] = [
+      makeIncident({ components: [{ id: "1", name: "BTC Node" }] }),
+      makeIncident({ components: [{ id: "2", name: "eth Node" }] }),
+      makeIncident({ components: [{ id: "3", name: "ADA-Service" }] }),
+      makeIncident({ components: [{ id: "4", name: "usdc gateway" }] }),
+      makeIncident({ components: [{ id: "5", name: "NOTUSDTService" }] }),
+      makeIncident({ components: [{ id: "6", name: "USDT" }] }),
+      makeIncident({ components: [{ id: "7", name: "xrp relayer" }] }),
+      makeIncident({ components: [{ id: "8", name: "SOL Node" }] }),
+      makeIncident({ components: [{ id: "9", name: "SOLANA Node" }] }),
+      makeIncident({ components: [{ id: "10", name: "Random Service" }] }),
+      makeIncident({ components: [] }),
+    ];
+
+    const result = filterServiceStatusIncidents(incidents, tickers);
+    expect(result.map(i => i.components?.[0]?.id)).toEqual(["1", "2", "3", "4", "6", "7", "8"]);
+    expect(result.length).toBe(8);
+  });
+});

package/src/notifications/ServiceStatusProvider/index.tsx

@@ -4,6 +4,9 @@ import defaultNetworkApi from "./api";
 import { fromPromise } from "xstate";
 import { useMachine } from "@xstate/react";
 import { serviceStatusMachine } from "./machine";
+import { LEDGER_COMPONENTS } from "./ledger-components";
+import { EntryPoint } from "./entry-points";
+
 type Props = {
   children: React.ReactNode;
   autoUpdateDelay: number;
@@ -33,21 +36,61 @@ function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()[\]\\]/g, "\\$&"); // $& means the whole matched string
 }
 
+function sanitizeName(name: string): string {
+  return name.toLowerCase().trim().replace(/\s+/g, " "); // collapse multiple spaces
+}
+
+/**
+ * Filters service status incidents based on related tickers or Ledger components.
+ *
+ * ## Behavior:
+ * - If there are no `tickers` or no `incidents`, returns an empty list.
+ * - For each incident:
+ *   1. ✅ If the incident has no components → keep it (always relevant).
+ *   2. ✅ If at least one component name matches a known **Ledger component** → keep it.
+ *   3. ✅ If at least one component name contains a **currency ticker** → keep it.
+ *   4. ❌ Otherwise, the incident is discarded.
+ *
+ * @param {Incident[]} [incidents=[]] - List of incidents to filter.
+ * @param {string[]} [tickers=[]] - List of currency tickers to match against incident components.
+ * @param {EntryPoint} [entryPoint] - Entry point where the incidents are displayed (specifically for Ledger components)
+ * @returns {Incident[]} The list of incidents relevant to the provided tickers or Ledger components.
+ */
+
 export function filterServiceStatusIncidents(
   incidents: Incident[],
   tickers: string[] = [],
+  entryPoint?: EntryPoint,
 ): Incident[] {
-  if (!tickers || tickers.length === 0 || !incidents || incidents.length === 0) {
-    return [];
-  }
-
-  const tickersRegex = new RegExp(escapeRegExp(tickers.join("|")), "i");
-  return incidents.filter(
-    ({ components }) =>
-      !components || // dont filter out if no components
-      components.length === 0 ||
-      components.some(({ name }) => tickersRegex.test(name)), // component name should hold currency ticker
-  );
+  if (!incidents.length) return [];
+  if (!tickers.length) return [];
+
+  const tickerRegex = tickers.length
+    ? new RegExp(`\\b(${tickers.map(escapeRegExp).join("|")})\\b`, "i")
+    : null;
+
+  const ledgerComponentsSet = new Set(LEDGER_COMPONENTS.map(component => sanitizeName(component)));
+
+  return incidents.filter(({ components }) => {
+    // Keep global incidents with no components
+    if (!components?.length) return true;
+
+    return components.some(({ name }) => {
+      const sanitizedName = sanitizeName(name);
+
+      // Show Ledger components only for Notification Center
+      if (entryPoint === "notifications" && ledgerComponentsSet.has(sanitizedName)) {
+        return true;
+      }
+
+      // Show coin/ticker-specific components for flows
+      if (tickerRegex && tickerRegex.test(sanitizedName)) {
+        return true;
+      }
+
+      return false;
+    });
+  });
 }
 
 // filter out service status incidents by given currencies or fallback on context currencies
@@ -55,8 +98,12 @@ export function useFilteredServiceStatus(filters?: ServiceStatusUserSettings): S
   const stateData = useContext(ServiceStatusContext);
   const { incidents, context } = stateData;
   const filteredIncidents = useMemo(() => {
-    return filterServiceStatusIncidents(incidents, filters?.tickers || context?.tickers);
-  }, [incidents, context, filters?.tickers]);
+    return filterServiceStatusIncidents(
+      incidents,
+      filters?.tickers || context?.tickers,
+      filters?.entryPoint,
+    );
+  }, [incidents, filters?.tickers, context?.tickers, filters?.entryPoint]);
 
   return { ...stateData, incidents: filteredIncidents };
 }
@@ -69,6 +116,7 @@ export const ServiceStatusProvider = ({
 }: Props): ReactElement => {
   const fetchData = useCallback(async () => {
     const serviceStatusSummary = await networkApi.fetchStatusSummary();
+
     return {
       incidents: serviceStatusSummary.incidents,
       updateTime: Date.now(),

package/src/notifications/ServiceStatusProvider/ledger-components.ts

@@ -0,0 +1,13 @@
+export const LEDGER_COMPONENTS = [
+  "Ledger Application Store",
+  "Ledger Live Security Services",
+  "Swap API",
+  "Buy",
+  "Earn Dashboard",
+  "Crypto Assets Service",
+  "Cloud Sync",
+  "Trustchain",
+  "Loyalty Program",
+  "Card Program",
+  "Countervalue API",
+] as const;