@ledgerhq/live-common 34.54.0-nightly.20251209023841 → 34.54.0

package/src/families/canton/react.test.ts

@@ -1,147 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-// Mock the bridge to avoid loading all bridge implementations with ESM dependencies
-jest.mock("../../bridge", () => ({
-  getCurrencyBridge: jest.fn(),
-}));
-
-import { renderHook, act } from "@testing-library/react";
-import { getRemainingTime, useTimeRemaining } from "./react";
-
-const MILLISECOND = 1000;
-const SECOND = 1 * MILLISECOND;
-const MINUTE = 60 * SECOND;
-const HOUR = 60 * MINUTE;
-const DAY = 24 * HOUR;
-
-describe("getRemainingTime", () => {
-  test("should return empty string for negative or zero diff", () => {
-    expect(getRemainingTime(0)).toBe("");
-    expect(getRemainingTime(-1000)).toBe("");
-    expect(getRemainingTime(-100000)).toBe("");
-  });
-
-  test("should format seconds only", () => {
-    expect(getRemainingTime(30 * SECOND)).toBe("30s");
-    expect(getRemainingTime(59 * SECOND)).toBe("59s");
-    expect(getRemainingTime(1 * SECOND)).toBe("1s");
-  });
-
-  test("should format minutes and seconds", () => {
-    expect(getRemainingTime(1 * MINUTE + 30 * SECOND)).toBe("1m 30s");
-    expect(getRemainingTime(5 * MINUTE + 15 * SECOND)).toBe("5m 15s");
-    expect(getRemainingTime(59 * MINUTE + 59 * SECOND)).toBe("59m 59s");
-  });
-
-  test("should format hours, minutes and seconds", () => {
-    expect(getRemainingTime(1 * HOUR + 30 * MINUTE + 15 * SECOND)).toBe("1h 30m 15s");
-    expect(getRemainingTime(2 * HOUR + 5 * MINUTE + 10 * SECOND)).toBe("2h 5m 10s");
-    expect(getRemainingTime(23 * HOUR + 59 * MINUTE + 59 * SECOND)).toBe("23h 59m 59s");
-  });
-
-  test("should format days, hours, minutes and seconds", () => {
-    expect(getRemainingTime(1 * DAY + 2 * HOUR + 30 * MINUTE + 15 * SECOND)).toBe("1d 2h 30m 15s");
-    expect(getRemainingTime(5 * DAY + 10 * HOUR + 5 * MINUTE + 10 * SECOND)).toBe("5d 10h 5m 10s");
-    expect(getRemainingTime(10 * DAY + 23 * HOUR + 59 * MINUTE + 59 * SECOND)).toBe(
-      "10d 23h 59m 59s",
-    );
-  });
-
-  test("should skip zero values", () => {
-    expect(getRemainingTime(1 * DAY)).toBe("1d 0s");
-    expect(getRemainingTime(1 * HOUR)).toBe("1h 0s");
-    expect(getRemainingTime(1 * MINUTE)).toBe("1m 0s");
-    expect(getRemainingTime(1 * DAY + 1 * MINUTE)).toBe("1d 1m 0s");
-    expect(getRemainingTime(1 * DAY + 1 * HOUR)).toBe("1d 1h 0s");
-  });
-});
-
-describe("useTimeRemaining", () => {
-  beforeAll(() => {
-    jest.useFakeTimers();
-  });
-
-  afterAll(() => {
-    jest.runOnlyPendingTimers();
-    jest.useRealTimers();
-  });
-
-  beforeEach(() => {
-    jest.setSystemTime(new Date("2024-01-01T12:00:00Z"));
-  });
-
-  test("should return empty string when proposal is null", () => {
-    const { result } = renderHook(() => useTimeRemaining());
-    expect(result.current).toBe("");
-  });
-
-  test("should return empty string when proposal is expired", () => {
-    const proposal = {
-      expiresAt: (Date.now() - 1000) * 1000, // 1 second ago
-      isExpired: true,
-    };
-    const { result } = renderHook(() => useTimeRemaining(proposal.expiresAt, proposal.isExpired));
-    expect(result.current).toBe("");
-  });
-
-  test("should return formatted time remaining for valid proposal", () => {
-    const expiresAt = Date.now() + 2 * HOUR + 30 * MINUTE + 15 * SECOND;
-    const { result } = renderHook(() => useTimeRemaining(expiresAt * 1000));
-    expect(result.current).toBe("2h 30m 15s");
-  });
-
-  test("should update time remaining every second", () => {
-    const expiresAt = Date.now() + 2 * MINUTE + 30 * SECOND;
-    const { result } = renderHook(() => useTimeRemaining(expiresAt * 1000));
-
-    expect(result.current).toBe("2m 30s");
-
-    act(() => {
-      jest.advanceTimersByTime(1 * SECOND);
-    });
-    expect(result.current).toBe("2m 29s");
-
-    act(() => {
-      jest.advanceTimersByTime(1 * SECOND);
-    });
-    expect(result.current).toBe("2m 28s");
-
-    act(() => {
-      jest.advanceTimersByTime(30 * SECOND);
-    });
-    expect(result.current).toBe("1m 58s");
-  });
-
-  test("should return empty string when time expires", () => {
-    const expiresAt = Date.now() + 2 * SECOND;
-    const { result } = renderHook(() => useTimeRemaining(expiresAt * 1000));
-
-    expect(result.current).toBe("2s");
-
-    act(() => {
-      jest.advanceTimersByTime(1 * SECOND);
-    });
-    expect(result.current).toBe("1s");
-
-    act(() => {
-      jest.advanceTimersByTime(1 * SECOND);
-    });
-    expect(result.current).toBe("");
-  });
-
-  test("should clear interval on unmount", () => {
-    const expiresAt = Date.now() + 1 * HOUR;
-    const { result, unmount } = renderHook(() => useTimeRemaining(expiresAt * 1000));
-
-    expect(result.current).toBe("1h 0s");
-
-    unmount();
-
-    // Advance time after unmount - should not cause errors
-    act(() => {
-      jest.advanceTimersByTime(1 * SECOND);
-    });
-  });
-});

package/src/families/hedera/react.test.ts

@@ -1,272 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import "../../__tests__/test-helpers/dom-polyfill";
-import BigNumber from "bignumber.js";
-import invariant from "invariant";
-import { getCurrentHederaPreloadData } from "@ledgerhq/coin-hedera/preload-data";
-import { apiClient } from "@ledgerhq/coin-hedera/network/api";
-import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import { renderHook } from "@testing-library/react";
-import { makeBridgeCacheSystem } from "../../bridge/cache";
-import { liveConfig } from "../../config/sharedConfig";
-import { getCryptoCurrencyById } from "../../currencies";
-import * as hooks from "./react";
-import type { HederaAccount, HederaDelegation } from "./types";
-
-const localCache: Record<string, unknown> = {};
-const cache = makeBridgeCacheSystem({
-  saveData(c, d) {
-    localCache[c.id] = d;
-    return Promise.resolve();
-  },
-  getData(c) {
-    return Promise.resolve(localCache[c.id]);
-  },
-});
-
-describe("hedera/react", () => {
-  const currency = getCryptoCurrencyById("hedera");
-
-  beforeAll(() => {
-    LiveConfig.setConfig(liveConfig);
-    jest.spyOn(apiClient, "getNodes").mockResolvedValue([
-      {
-        description: "Hosted by LG | Seoul, South Korea",
-        node_id: 0,
-        node_account_id: "0.0.3",
-        stake: 45000000000000000,
-        stake_rewarded: 86596417100000000,
-        min_stake: 0,
-        max_stake: 45000000000000000,
-        reward_rate_start: 3500,
-      },
-      {
-        description: "Hosted by Swirlds | Iowa, USA",
-        node_id: 1,
-        node_account_id: "0.0.4",
-        stake: 45000000000000000,
-        stake_rewarded: 88990261300000000,
-        min_stake: 0,
-        max_stake: 45000000000000000,
-        reward_rate_start: 4000,
-      },
-      {
-        description: "Hosted for Wipro | Amsterdam, Netherlands",
-        node_id: 3,
-        node_account_id: "0.0.6",
-        stake: 45000000000000000,
-        stake_rewarded: 21477855400000000,
-        min_stake: 0,
-        max_stake: 45000000000000000,
-        reward_rate_start: 5000,
-      },
-    ]);
-  });
-
-  describe("useHederaPreloadData", () => {
-    beforeEach(async () => {
-      const { prepare } = setup();
-      await prepare();
-    });
-
-    it("should return preloaded data", async () => {
-      const { result } = renderHook(() => hooks.useHederaPreloadData(currency));
-      const data = getCurrentHederaPreloadData(currency);
-
-      expect(result.current).toStrictEqual(data);
-    });
-  });
-
-  describe("useHederaValidators", () => {
-    beforeEach(async () => {
-      const { prepare } = setup();
-      await prepare();
-    });
-
-    it("should return all validators when no search query", () => {
-      const { result } = renderHook(() => hooks.useHederaValidators(currency));
-      const data = getCurrentHederaPreloadData(currency);
-
-      expect(result.current).toEqual(data.validators);
-    });
-
-    it("should return all validators when search query is empty string", () => {
-      const { result } = renderHook(() => hooks.useHederaValidators(currency, ""));
-      const data = getCurrentHederaPreloadData(currency);
-
-      expect(result.current).toEqual(data.validators);
-    });
-
-    it("should filter validators by name", () => {
-      const { result } = renderHook(() => hooks.useHederaValidators(currency, "Swirlds"));
-
-      expect(result.current.length).toBeGreaterThan(0);
-      result.current.forEach(validator => {
-        expect(validator.name.toLowerCase()).toContain("swirlds");
-      });
-    });
-
-    it("should filter validators by node ID", () => {
-      const data = getCurrentHederaPreloadData(currency);
-      const firstValidator = data.validators[0];
-
-      if (firstValidator) {
-        const { result } = renderHook(() =>
-          hooks.useHederaValidators(currency, firstValidator.nodeId.toString()),
-        );
-
-        expect(result.current.length).toBeGreaterThan(0);
-        expect(result.current.some(v => v.nodeId === firstValidator.nodeId)).toBe(true);
-      }
-    });
-
-    it("should return empty array when no validators match search", () => {
-      const { result } = renderHook(() =>
-        hooks.useHederaValidators(currency, "nonexistingvalidator"),
-      );
-
-      expect(result.current).toEqual([]);
-    });
-
-    it("should be case insensitive when filtering", () => {
-      const { result: upperResult } = renderHook(() =>
-        hooks.useHederaValidators(currency, "SWIRLDS"),
-      );
-      const { result: lowerResult } = renderHook(() =>
-        hooks.useHederaValidators(currency, "swirlds"),
-      );
-
-      expect(upperResult.current.length).toEqual(lowerResult.current.length);
-    });
-  });
-
-  describe("useHederaEnrichedDelegation", () => {
-    const mockAccount = {
-      type: "Account",
-      id: "mock-account-id",
-      currency,
-      balance: new BigNumber(1000000),
-      spendableBalance: new BigNumber(1000000),
-      hederaResources: {
-        delegation: null,
-      },
-    } as HederaAccount;
-
-    beforeEach(async () => {
-      const { prepare } = setup();
-      await prepare();
-    });
-
-    it("should enrich delegation with validator data", () => {
-      const data = getCurrentHederaPreloadData(currency);
-      const validator = data.validators[0];
-      invariant(validator, "No validators available for test");
-
-      const delegation: HederaDelegation = {
-        nodeId: validator.nodeId,
-        delegated: new BigNumber(100000),
-        pendingReward: new BigNumber(500),
-      };
-
-      const { result } = renderHook(() =>
-        hooks.useHederaEnrichedDelegation(mockAccount, delegation),
-      );
-
-      expect(result.current).toEqual({
-        nodeId: validator.nodeId,
-        delegated: delegation.delegated,
-        pendingReward: delegation.pendingReward,
-        status: "overstaked",
-        validator: {
-          name: validator.name,
-          address: validator.address,
-          addressChecksum: validator.addressChecksum,
-          nodeId: validator.nodeId,
-          minStake: validator.minStake,
-          maxStake: validator.maxStake,
-          activeStake: validator.activeStake,
-          activeStakePercentage: validator.activeStakePercentage,
-          overstaked: validator.overstaked,
-        },
-      });
-    });
-
-    it("should handle delegation with non-existent validator", () => {
-      const delegation: HederaDelegation = {
-        nodeId: 999999,
-        delegated: new BigNumber(100000),
-        pendingReward: new BigNumber(500),
-      };
-
-      const { result } = renderHook(() =>
-        hooks.useHederaEnrichedDelegation(mockAccount, delegation),
-      );
-
-      expect(result.current).toEqual({
-        nodeId: delegation.nodeId,
-        delegated: delegation.delegated,
-        pendingReward: delegation.pendingReward,
-        status: "inactive",
-        validator: {
-          name: "",
-          address: "",
-          addressChecksum: null,
-          nodeId: delegation.nodeId,
-          minStake: new BigNumber(0),
-          maxStake: new BigNumber(0),
-          activeStake: new BigNumber(0),
-          activeStakePercentage: new BigNumber(0),
-          overstaked: false,
-        },
-      });
-    });
-
-    it("should handle delegation with zero staked amount", () => {
-      const data = getCurrentHederaPreloadData(currency);
-      const validator = data.validators[0];
-      invariant(validator, "No validators available for test");
-
-      const delegation: HederaDelegation = {
-        nodeId: validator.nodeId,
-        delegated: new BigNumber(0),
-        pendingReward: new BigNumber(0),
-      };
-
-      const { result } = renderHook(() =>
-        hooks.useHederaEnrichedDelegation(mockAccount, delegation),
-      );
-
-      expect(result.current.delegated).toEqual(new BigNumber(0));
-      expect(result.current.validator.nodeId).toEqual(validator.nodeId);
-    });
-
-    it("should handle delegation with pending rewards", () => {
-      const data = getCurrentHederaPreloadData(currency);
-      const validator = data.validators[0];
-      invariant(validator, "No validators available for test");
-
-      const delegation: HederaDelegation = {
-        nodeId: validator.nodeId,
-        delegated: new BigNumber(100000),
-        pendingReward: new BigNumber(1500),
-      };
-
-      const { result } = renderHook(() =>
-        hooks.useHederaEnrichedDelegation(mockAccount, delegation),
-      );
-
-      expect(result.current.pendingReward).toEqual(new BigNumber(1500));
-    });
-  });
-});
-
-function setup(): {
-  prepare: () => Promise<unknown>;
-} {
-  const currency = getCryptoCurrencyById("hedera");
-
-  return {
-    prepare: async () => cache.prepareCurrency(currency),
-  };
-}

package/src/families/hedera/react.ts

@@ -1,63 +0,0 @@
-import BigNumber from "bignumber.js";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { useMemo } from "react";
-import {
-  getCurrentHederaPreloadData,
-  getHederaPreloadData,
-} from "@ledgerhq/coin-hedera/preload-data";
-import { getDelegationStatus, filterValidatorBySearchTerm } from "./utils";
-import { useObservable } from "../../observable";
-import type {
-  HederaAccount,
-  HederaPreloadData,
-  HederaValidator,
-  HederaDelegation,
-  HederaEnrichedDelegation,
-} from "./types";
-
-export function useHederaPreloadData(
-  currency: CryptoCurrency,
-): HederaPreloadData | undefined | null {
-  return useObservable(getHederaPreloadData(currency), getCurrentHederaPreloadData(currency));
-}
-
-export function useHederaValidators(currency: CryptoCurrency, search?: string): HederaValidator[] {
-  const data = useHederaPreloadData(currency);
-
-  return useMemo(() => {
-    const validators = data?.validators ?? [];
-
-    if (validators.length === 0 || !search || search === "") {
-      return validators;
-    }
-
-    return validators.filter(validator => {
-      return filterValidatorBySearchTerm(validator, search);
-    });
-  }, [data, search]);
-}
-
-export function useHederaEnrichedDelegation(
-  account: HederaAccount,
-  delegation: HederaDelegation,
-): HederaEnrichedDelegation {
-  const validators = useHederaValidators(account.currency);
-  const validatorByNodeId = new Map(validators.map(v => [v.nodeId, v]));
-  const validator = validatorByNodeId.get(delegation.nodeId) ?? null;
-
-  return {
-    ...delegation,
-    status: getDelegationStatus(validator),
-    validator: {
-      name: validator?.name ?? "",
-      address: validator?.address ?? "",
-      addressChecksum: validator?.addressChecksum ?? null,
-      nodeId: delegation.nodeId,
-      minStake: validator?.minStake ?? new BigNumber(0),
-      maxStake: validator?.maxStake ?? new BigNumber(0),
-      activeStake: validator?.activeStake ?? new BigNumber(0),
-      activeStakePercentage: validator?.activeStakePercentage ?? new BigNumber(0),
-      overstaked: validator?.overstaked ?? false,
-    },
-  };
-}

package/src/helpers/cryptoIconSize.ts

@@ -1,25 +0,0 @@
-// Utility to map any size to valid crypto-icons sizes
-// For React Native (returns numbers)
-export const getValidCryptoIconSizeNative = (size: number): 16 | 20 | 24 | 32 | 40 | 48 | 56 => {
-  if (size <= 16) return 16;
-  if (size <= 20) return 20;
-  if (size <= 24) return 24;
-  if (size <= 32) return 32;
-  if (size <= 40) return 40;
-  if (size <= 48) return 48;
-  return 56;
-};
-
-// Utility to map any size to valid crypto-icons sizes
-// For React/Web (returns strings with "px")
-export const getValidCryptoIconSize = (
-  size: number,
-): "16px" | "20px" | "24px" | "32px" | "40px" | "48px" | "56px" => {
-  if (size <= 16) return "16px";
-  if (size <= 20) return "20px";
-  if (size <= 24) return "24px";
-  if (size <= 32) return "32px";
-  if (size <= 40) return "40px";
-  if (size <= 48) return "48px";
-  return "56px";
-};

package/src/hooks/__tests__/useHtmlLinkSegments.test.ts

@@ -1,105 +0,0 @@
-import {
-  buildHtmlDisplaySegments,
-  splitHtmlLinkSegments,
-  validateLedgerUrl,
-} from "../useHtmlLinkSegments";
-
-describe("splitHtmlLinkSegments", () => {
-  it("returns an empty array when input is empty", () => {
-    expect(splitHtmlLinkSegments("")).toEqual([]);
-  });
-
-  it("returns only text segments when there are no anchors", () => {
-    const segments = splitHtmlLinkSegments("simple text without links");
-    expect(segments).toEqual([{ type: "text", content: "simple text without links" }]);
-  });
-
-  it("splits text into text and link segments", () => {
-    const segments = splitHtmlLinkSegments('Hello <a href="https://ledger.com">Ledger</a> !');
-
-    expect(segments).toEqual([
-      { type: "text", content: "Hello " },
-      { type: "link", label: "Ledger", href: "https://ledger.com" },
-      { type: "text", content: " !" },
-    ]);
-  });
-
-  it("keeps whitespace-only text segments", () => {
-    const segments = splitHtmlLinkSegments(
-      '<a href="https://ledger.com">Ledger</a> <a href="https://support.ledger.com">Support</a>',
-    );
-
-    expect(segments).toEqual([
-      { type: "link", label: "Ledger", href: "https://ledger.com" },
-      { type: "text", content: " " },
-      { type: "link", label: "Support", href: "https://support.ledger.com" },
-    ]);
-  });
-});
-
-describe("buildHtmlDisplaySegments", () => {
-  it("keeps valid ledger links clickable", () => {
-    const segments = buildHtmlDisplaySegments(
-      'Visit <a href="https://support.ledger.com">support</a> docs',
-    );
-
-    expect(segments).toEqual([
-      { type: "text", content: "Visit " },
-      { type: "link", href: "https://support.ledger.com", label: "support" },
-      { type: "text", content: " docs" },
-    ]);
-  });
-
-  it("falls back to text segments for non-ledger links", () => {
-    const segments = buildHtmlDisplaySegments('Check <a href="https://example.com">here</a>');
-
-    expect(segments).toEqual([
-      { type: "text", content: "Check " },
-      { type: "text", content: "here" },
-    ]);
-  });
-
-  it("ignores invalid protocols", () => {
-    const segments = buildHtmlDisplaySegments('Bad <a href="javascript:alert(1)">click</a>');
-
-    expect(segments).toEqual([
-      { type: "text", content: "Bad " },
-      { type: "text", content: "click" },
-    ]);
-  });
-});
-
-describe("validateLedgerUrl", () => {
-  it("accepts ledger http(s) URLs", () => {
-    expect(validateLedgerUrl("https://ledger.com")).toEqual({
-      isHttp: true,
-      isAllowedLedgerDomain: true,
-    });
-
-    expect(validateLedgerUrl("https://support.ledger.com/hc/en-us")).toEqual({
-      isHttp: true,
-      isAllowedLedgerDomain: true,
-    });
-  });
-
-  it("rejects non-http protocols", () => {
-    expect(validateLedgerUrl("ledgerlive://settings")).toEqual({
-      isHttp: false,
-      isAllowedLedgerDomain: false,
-    });
-  });
-
-  it("rejects non-ledger domains", () => {
-    expect(validateLedgerUrl("https://example.com")).toEqual({
-      isHttp: true,
-      isAllowedLedgerDomain: false,
-    });
-  });
-
-  it("rejects invalid URLs", () => {
-    expect(validateLedgerUrl("not a url")).toEqual({
-      isHttp: false,
-      isAllowedLedgerDomain: false,
-    });
-  });
-});