@ledgerhq/live-common 34.54.0-nightly.20251209144712 → 34.54.1

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,
-    });
-  });
-});

package/src/hooks/useHtmlLinkSegments.ts

@@ -1,158 +0,0 @@
-import { useMemo } from "react";
-
-export type HtmlLinkSegment =
-  | {
-      type: "text";
-      content: string;
-    }
-  | {
-      type: "link";
-      label: string;
-      href: string;
-    };
-
-const ANCHOR_OPEN_REGEX = /<a\b[^>]*>/gi;
-const HREF_ATTR_REGEX = /href\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s'">]+))/i;
-const CLOSING_ANCHOR = "</a>";
-
-export const splitHtmlLinkSegments = (input: string): HtmlLinkSegment[] => {
-  const segments: HtmlLinkSegment[] = [];
-
-  if (!input) {
-    return segments;
-  }
-
-  const lowerInput = input.toLowerCase();
-  let cursor = 0;
-  ANCHOR_OPEN_REGEX.lastIndex = 0;
-
-  const extractHrefValue = (tag: string): string | null => {
-    const match = HREF_ATTR_REGEX.exec(tag);
-    if (!match) return null;
-    return match[1] ?? match[2] ?? match[3] ?? null;
-  };
-
-  let match: RegExpExecArray | null;
-  while ((match = ANCHOR_OPEN_REGEX.exec(input)) !== null) {
-    const startIndex = match.index;
-    const tag = match[0];
-    const contentStartIndex = startIndex + tag.length;
-    const closingIndex = lowerInput.indexOf(CLOSING_ANCHOR, contentStartIndex);
-
-    if (closingIndex === -1) {
-      break;
-    }
-
-    if (startIndex > cursor) {
-      const textBefore = input.slice(cursor, startIndex);
-      if (textBefore) {
-        segments.push({
-          type: "text",
-          content: textBefore,
-        });
-      }
-    }
-
-    const href = extractHrefValue(tag);
-    if (href) {
-      const label = input.slice(contentStartIndex, closingIndex);
-      segments.push({
-        type: "link",
-        href,
-        label,
-      });
-    } else {
-      const fallbackText = input.slice(startIndex, closingIndex + CLOSING_ANCHOR.length);
-      segments.push({
-        type: "text",
-        content: fallbackText,
-      });
-    }
-
-    cursor = closingIndex + CLOSING_ANCHOR.length;
-    ANCHOR_OPEN_REGEX.lastIndex = cursor;
-  }
-
-  if (cursor < input.length) {
-    const textAfter = input.slice(cursor);
-    if (textAfter) {
-      segments.push({
-        type: "text",
-        content: textAfter,
-      });
-    }
-  }
-
-  return segments;
-};
-
-export const validateLedgerUrl = (
-  href: string,
-): { isHttp: boolean; isAllowedLedgerDomain: boolean } => {
-  try {
-    const url = new URL(href);
-    const isHttp = url.protocol === "http:" || url.protocol === "https:";
-
-    if (!isHttp) {
-      return {
-        isHttp: false,
-        isAllowedLedgerDomain: false,
-      };
-    }
-
-    const hostname = url.hostname.toLowerCase();
-    const isAllowedLedgerDomain = hostname === "ledger.com" || hostname.endsWith(".ledger.com");
-
-    return {
-      isHttp,
-      isAllowedLedgerDomain,
-    };
-  } catch {
-    return {
-      isHttp: false,
-      isAllowedLedgerDomain: false,
-    };
-  }
-};
-
-export const buildHtmlDisplaySegments = (input: string): HtmlLinkSegment[] => {
-  return splitHtmlLinkSegments(input).map(segment => {
-    if (segment.type === "link") {
-      const { isHttp, isAllowedLedgerDomain } = validateLedgerUrl(segment.href);
-
-      if (isHttp && isAllowedLedgerDomain) {
-        return segment;
-      }
-
-      return {
-        type: "text",
-        content: segment.label,
-      };
-    }
-
-    return segment;
-  });
-};
-
-export const useHtmlLinkSegments = (
-  html?: string | null,
-): {
-  segments: HtmlLinkSegment[];
-  hasLinks: boolean;
-} => {
-  return useMemo(() => {
-    if (!html) {
-      return {
-        segments: [],
-        hasLinks: false,
-      };
-    }
-
-    const segments = buildHtmlDisplaySegments(html);
-
-    return {
-      segments,
-      hasLinks: segments.some(segment => segment.type === "link"),
-    };
-  }, [html]);
-};