@ledgerhq/live-common 34.52.0-nightly.1 → 34.52.0-nightly.10

package/src/families/hedera/utils.ts

@@ -0,0 +1,2 @@
+// Encapsulate for LLD & LLM
+export * from "@ledgerhq/coin-hedera/logic/utils";

package/src/families/sui/react.ts

@@ -110,6 +110,11 @@ export const mapStakingPositions = (
       validator,
       stakedSuiId: sp.stakedSuiId,
       formattedAmount: formatCurrencyUnit(unit, BigNumber(sp.principal), formatConfig),
+      formattedEstimatedReward: formatCurrencyUnit(
+        unit,
+        BigNumber(sp.status === "Active" ? sp.estimatedReward : 0),
+        formatConfig,
+      ),
     };
   });
 };

package/src/featureFlags/defaultFeatures.ts

@@ -97,12 +97,15 @@ export const CURRENCY_DEFAULT_FEATURES = {
   currencyBerachain: DEFAULT_FEATURE,
   currencyHyperevm: DEFAULT_FEATURE,
   currencyCantonNetwork: DEFAULT_FEATURE,
+  currencyCantonNetworkDevnet: DEFAULT_FEATURE,
+  currencyCantonNetworkTestnet: DEFAULT_FEATURE,
   currencyKaspa: DEFAULT_FEATURE,
   currencyEthereumHoodi: DEFAULT_FEATURE,
   currencyCore: DEFAULT_FEATURE,
   currencyWestend: DEFAULT_FEATURE,
   currencyAssetHubPolkadot: DEFAULT_FEATURE,
   currencyAssetHubWestend: DEFAULT_FEATURE,
+  currencyMonad: DEFAULT_FEATURE,
 };
 
 /**

package/src/hooks/useDeviceTransactionConfig.test.tsx

@@ -0,0 +1,200 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { TextDecoder, TextEncoder } from "util";
+
+// Polyfill for TextDecoder/TextEncoder required by Cardano dependencies
+global.TextDecoder = TextDecoder as any;
+global.TextEncoder = TextEncoder as any;
+
+// Mock the deviceTransactionConfig module before importing anything else
+jest.mock("../transaction/deviceTransactionConfig", () => ({
+  getDeviceTransactionConfig: jest.fn(),
+}));
+
+import { renderHook, waitFor } from "@testing-library/react";
+import { useDeviceTransactionConfig } from "./useDeviceTransactionConfig";
+import { getDeviceTransactionConfig } from "../transaction/deviceTransactionConfig";
+import { Account } from "@ledgerhq/types-live";
+import { Transaction, TransactionStatus } from "../generated/types";
+import BigNumber from "bignumber.js";
+import { getCryptoCurrencyById } from "../currencies/index";
+
+const mockGetDeviceTransactionConfig = getDeviceTransactionConfig as jest.MockedFunction<
+  typeof getDeviceTransactionConfig
+>;
+
+const btc = getCryptoCurrencyById("bitcoin");
+
+describe("useDeviceTransactionConfig", () => {
+  const mockAccount: Account = {
+    type: "Account",
+    id: "test-account-id",
+    seedIdentifier: "seed-id",
+    derivationMode: "" as const,
+    index: 0,
+    freshAddress: "test-address",
+    freshAddressPath: "44'/0'/0'/0/0",
+    used: true,
+    balance: new BigNumber(1000000),
+    spendableBalance: new BigNumber(1000000),
+    creationDate: new Date(),
+    blockHeight: 100,
+    currency: btc,
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: new Date(),
+    balanceHistoryCache: {
+      HOUR: { latestDate: null, balances: [] },
+      DAY: { latestDate: null, balances: [] },
+      WEEK: { latestDate: null, balances: [] },
+    },
+    swapHistory: [],
+  };
+
+  const mockTransaction: Transaction = {
+    family: "bitcoin" as any,
+    amount: new BigNumber(100),
+    recipient: "test-recipient",
+    useAllAmount: false,
+  } as Transaction;
+
+  const mockStatus: TransactionStatus = {
+    errors: {},
+    warnings: {},
+    estimatedFees: new BigNumber(10),
+    amount: new BigNumber(100),
+    totalSpent: new BigNumber(110),
+  } as TransactionStatus;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should load device transaction config fields successfully", async () => {
+    const mockFields = [
+      { type: "amount", label: "Amount" },
+      { type: "fees", label: "Fees" },
+    ];
+
+    mockGetDeviceTransactionConfig.mockResolvedValue(mockFields as any);
+
+    const { result } = renderHook(() =>
+      useDeviceTransactionConfig({
+        account: mockAccount,
+        parentAccount: null,
+        transaction: mockTransaction,
+        status: mockStatus,
+      }),
+    );
+
+    // Initially loading
+    expect(result.current.loading).toBe(true);
+    expect(result.current.fields).toEqual([]);
+
+    // Wait for async operation
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.fields).toEqual(mockFields);
+    expect(mockGetDeviceTransactionConfig).toHaveBeenCalledWith({
+      account: mockAccount,
+      parentAccount: null,
+      transaction: mockTransaction,
+      status: mockStatus,
+    });
+  });
+
+  it("should handle errors gracefully", async () => {
+    const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation();
+    mockGetDeviceTransactionConfig.mockRejectedValue(new Error("Test error"));
+
+    const { result } = renderHook(() =>
+      useDeviceTransactionConfig({
+        account: mockAccount,
+        parentAccount: null,
+        transaction: mockTransaction,
+        status: mockStatus,
+      }),
+    );
+
+    expect(result.current.loading).toBe(true);
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.fields).toEqual([]);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      "Failed to load device transaction config:",
+      expect.any(Error),
+    );
+
+    consoleErrorSpy.mockRestore();
+  });
+
+  it("should reload fields when dependencies change", async () => {
+    const mockFields1 = [{ type: "amount", label: "Amount 1" }];
+    const mockFields2 = [{ type: "amount", label: "Amount 2" }];
+
+    mockGetDeviceTransactionConfig
+      .mockResolvedValueOnce(mockFields1 as any)
+      .mockResolvedValueOnce(mockFields2 as any);
+
+    const { result, rerender } = renderHook(
+      ({ transaction }) =>
+        useDeviceTransactionConfig({
+          account: mockAccount,
+          parentAccount: null,
+          transaction,
+          status: mockStatus,
+        }),
+      {
+        initialProps: { transaction: mockTransaction },
+      },
+    );
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.fields).toEqual(mockFields1);
+
+    // Change transaction
+    const newTransaction = {
+      ...mockTransaction,
+      amount: new BigNumber(200),
+    };
+
+    rerender({ transaction: newTransaction });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.fields).toEqual(mockFields2);
+    expect(mockGetDeviceTransactionConfig).toHaveBeenCalledTimes(2);
+  });
+
+  it("should cleanup on unmount", async () => {
+    const mockFields = [{ type: "amount", label: "Amount" }];
+    mockGetDeviceTransactionConfig.mockResolvedValue(mockFields as any);
+
+    const { unmount } = renderHook(() =>
+      useDeviceTransactionConfig({
+        account: mockAccount,
+        parentAccount: null,
+        transaction: mockTransaction,
+        status: mockStatus,
+      }),
+    );
+
+    unmount();
+
+    // Should not throw any errors
+    expect(mockGetDeviceTransactionConfig).toHaveBeenCalled();
+  });
+});

package/src/hooks/useDeviceTransactionConfig.ts

@@ -0,0 +1,65 @@
+import { useState, useEffect } from "react";
+import { Account, AccountLike } from "@ledgerhq/types-live";
+import { Transaction, TransactionStatus } from "../generated/types";
+import {
+  getDeviceTransactionConfig,
+  DeviceTransactionField,
+} from "../transaction/deviceTransactionConfig";
+
+type UseDeviceTransactionConfigParams = {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+};
+
+/**
+ * Hook to fetch device transaction configuration fields asynchronously.
+ * This anticipates the future async nature of crypto assets store operations.
+ */
+export function useDeviceTransactionConfig({
+  account,
+  parentAccount,
+  transaction,
+  status,
+}: UseDeviceTransactionConfigParams): {
+  fields: DeviceTransactionField[];
+  loading: boolean;
+} {
+  const [fields, setFields] = useState<DeviceTransactionField[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    let mounted = true;
+
+    async function loadFields() {
+      try {
+        setLoading(true);
+        const result = await getDeviceTransactionConfig({
+          account,
+          parentAccount,
+          transaction,
+          status,
+        });
+        if (mounted) {
+          setFields(result);
+          setLoading(false);
+        }
+      } catch (error) {
+        console.error("Failed to load device transaction config:", error);
+        if (mounted) {
+          setFields([]);
+          setLoading(false);
+        }
+      }
+    }
+
+    loadFields();
+
+    return () => {
+      mounted = false;
+    };
+  }, [account, parentAccount, transaction, status]);
+
+  return { fields, loading };
+}

package/src/load/speculos.ts

@@ -28,6 +28,7 @@ export { closeAllSpeculosDevices, releaseSpeculosDevice, createSpeculosDevice };
 export type { SpeculosTransport };
 
 const modelMapPriority: Record<string, number> = {
+  flex: 6,
   stax: 5,
   nanos: 4,
   "nanos+": 3,

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

@@ -7,6 +7,7 @@ export const mockArbitrumCryptoCurrency = getCryptoCurrencyById("arbitrum");
 export const mockBaseCryptoCurrency = getCryptoCurrencyById("base");
 export const mockScrollCryptoCurrency = getCryptoCurrencyById("scroll");
 export const mockInjectiveCryptoCurrency = getCryptoCurrencyById("injective");
+export const mockBscCryptoCurrency = getCryptoCurrencyById("bsc");
 
 export const arbitrumToken: TokenCurrency = {
   type: "TokenCurrency",
@@ -41,6 +42,45 @@ export const usdcToken: TokenCurrency = {
   ],
 };
 
+export const maticEth: TokenCurrency = {
+  type: "TokenCurrency" as const,
+  id: "ethereum/erc20/matic",
+  ledgerSignature: "",
+  contractAddress: "0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0",
+  parentCurrency: mockEthCryptoCurrency,
+  tokenType: "erc20" as const,
+  name: "Matic",
+  ticker: "MATIC",
+  delisted: false,
+  disableCountervalue: false,
+  units: [
+    {
+      name: "Matic",
+      code: "MATIC",
+      magnitude: 18,
+    },
+  ],
+};
+
+export const maticBsc: TokenCurrency = {
+  type: "TokenCurrency" as const,
+  id: "bsc/bep20/matic_token",
+  ledgerSignature: "",
+  contractAddress: "0xCC42724C6683B7E57334c4E856f4c9965ED682bD",
+  parentCurrency: mockBscCryptoCurrency,
+  tokenType: "bep20" as const,
+  name: "Matic Token",
+  ticker: "MATIC",
+  delisted: false,
+  disableCountervalue: false,
+  units: [
+    {
+      name: "Matic Token",
+      code: "MATIC",
+      magnitude: 18,
+    },
+  ],
+};
 export const findCryptoCurrencyById = (id: string) =>
   [mockBtcCryptoCurrency, mockEthCryptoCurrency, mockArbitrumCryptoCurrency].find(a => a.id === id);
 export const getTokenOrCryptoCurrencyById = (id: string) =>

package/src/modularDrawer/hooks/useCurrenciesUnderFeatureFlag.ts

@@ -70,6 +70,8 @@ export function useCurrenciesUnderFeatureFlag() {
   const berachain = useFeature("currencyBerachain");
   const hyperevm = useFeature("currencyHyperevm");
   const canton = useFeature("currencyCantonNetwork");
+  const cantonDevnet = useFeature("currencyCantonNetworkDevnet");
+  const cantonTestnet = useFeature("currencyCantonNetworkTestnet");
   const kaspa = useFeature("currencyKaspa");
   const core = useFeature("currencyCore");
   const ethereumHoodi = useFeature("currencyEthereumHoodi");
@@ -77,6 +79,7 @@ export function useCurrenciesUnderFeatureFlag() {
   const assetHubWestend = useFeature("currencyAssetHubWestend");
   const assetHubPolkadot = useFeature("currencyAssetHubPolkadot");
   const polkadot = useFeature("currencyPolkadot");
+  const monad = useFeature("currencyMonad");
 
   const featureFlaggedCurrencies = useMemo(
     (): Partial<Record<CryptoCurrencyId, Feature<unknown> | null>> => ({
@@ -143,6 +146,8 @@ export function useCurrenciesUnderFeatureFlag() {
       mina,
       babylon,
       canton_network: canton,
+      canton_network_devnet: cantonDevnet,
+      canton_network_testnet: cantonTestnet,
       kaspa,
       core,
       ethereum_hoodi: ethereumHoodi,
@@ -150,6 +155,7 @@ export function useCurrenciesUnderFeatureFlag() {
       assethub_westend: assetHubWestend,
       assethub_polkadot: assetHubPolkadot,
       polkadot,
+      monad,
     }),
     [
       aptos,
@@ -222,6 +228,7 @@ export function useCurrenciesUnderFeatureFlag() {
       assetHubWestend,
       assetHubPolkadot,
       polkadot,
+      monad,
     ],
   );
 

package/src/modularDrawer/utils/index.ts

@@ -2,17 +2,13 @@ import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 export { groupCurrenciesByProvider } from "./groupCurrenciesByProvider";
 export { sortAccountsByFiatValue } from "./sortAccountsByFiatValue";
 
-function isCorrespondingCurrency(
+const getBaseId = (currency: CryptoOrTokenCurrency) =>
+  currency.type === "CryptoCurrency" ? currency.id : currency.parentCurrency.id;
+
+function belongsToSameNetwork(
   elem: CryptoOrTokenCurrency,
   network: CryptoOrTokenCurrency,
 ): boolean {
-  if (elem.type === "TokenCurrency") {
-    return elem.parentCurrency?.id === network.id || elem.id === network.id;
-  }
-  if (elem.type === "CryptoCurrency") {
-    return elem.id === network.id;
-  }
-  return false;
+  return getBaseId(elem) === getBaseId(network);
 }
-
-export { isCorrespondingCurrency };
+export { getBaseId, belongsToSameNetwork };

package/src/postOnboarding/hooks/useAutoDismissPostOnboardingEntryPoint.ts

@@ -6,7 +6,7 @@ import { usePostOnboardingEntryPointVisibleOnWallet } from "./usePostOnboardingE
 
 const millisecondsInADay = 1000 * 60 * 60 * 24;
 
-const isMoreThanSevenDaysAgo = (date: Date) => {
+const isMoreThanSevenDaysAgo = (date: Date | null) => {
   if (!date) return false;
 
   const datePlusSevenDays = new Date(date).getTime() + 7 * millisecondsInADay;

package/src/postOnboarding/hooks/usePostOnboardingHubState.ts

@@ -26,15 +26,13 @@ export function usePostOnboardingHubState(): PostOnboardingHubState {
         actionsState: [],
         postOnboardingInProgress: hubState.postOnboardingInProgress,
       };
-    const actionsState = hubState.actionsToComplete
-      .map(actionId => ({
-        ...getPostOnboardingAction(actionId),
-        completed: !!hubState.actionsCompleted[actionId],
-      }))
-      .filter(
-        actionWithState =>
-          !actionWithState.featureFlagId || getFeature(actionWithState.featureFlagId)?.enabled,
-      );
+    const actionsState = hubState.actionsToComplete.flatMap(actionId => {
+      const action = getPostOnboardingAction(actionId);
+      if (!action || (action.featureFlagId && !getFeature(action.featureFlagId)?.enabled)) {
+        return [];
+      }
+      return [{ ...action, completed: !!hubState.actionsCompleted[actionId] }];
+    });
     const lastActionCompleted = hubState.lastActionCompleted
       ? getPostOnboardingAction(hubState.lastActionCompleted)
       : null;

package/src/transaction/deviceTransactionConfig.ts

@@ -6,14 +6,14 @@ import { getMainAccount } from "../account";
 import type { Account, AccountLike } from "@ledgerhq/types-live";
 
 export type DeviceTransactionField = CommonDeviceTransactionField | ExtraDeviceTransactionField;
-export function getDeviceTransactionConfig(arg: {
+export async function getDeviceTransactionConfig(arg: {
   account: AccountLike;
   parentAccount: Account | null | undefined;
   transaction: Transaction;
   status: TransactionStatus;
-}): Array<DeviceTransactionField> {
+}): Promise<Array<DeviceTransactionField>> {
   const mainAccount = getMainAccount(arg.account, arg.parentAccount);
   const f = perFamily[mainAccount.currency.family];
   if (!f) return [];
-  return f(arg);
+  return await f(arg);
 }

package/lib/families/hedera/logic.d.ts

@@ -1,2 +0,0 @@
-export * from "@ledgerhq/coin-hedera/logic";
-//# sourceMappingURL=logic.d.ts.map

package/lib/families/hedera/logic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logic.d.ts","sourceRoot":"","sources":["../../../src/families/hedera/logic.ts"],"names":[],"mappings":"AACA,cAAc,6BAA6B,CAAC"}

package/lib/families/hedera/logic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"logic.js","sourceRoot":"","sources":["../../../src/families/hedera/logic.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4BAA4B;AAC5B,8DAA4C"}

package/lib-es/families/hedera/logic.d.ts

@@ -1,2 +0,0 @@
-export * from "@ledgerhq/coin-hedera/logic";
-//# sourceMappingURL=logic.d.ts.map

package/lib-es/families/hedera/logic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logic.d.ts","sourceRoot":"","sources":["../../../src/families/hedera/logic.ts"],"names":[],"mappings":"AACA,cAAc,6BAA6B,CAAC"}

package/lib-es/families/hedera/logic.js

@@ -1,3 +0,0 @@
-// Encapsulate for LLD & LLM
-export * from "@ledgerhq/coin-hedera/logic";
-//# sourceMappingURL=logic.js.map

package/lib-es/families/hedera/logic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"logic.js","sourceRoot":"","sources":["../../../src/families/hedera/logic.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,cAAc,6BAA6B,CAAC"}