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

package/src/account/recentAddresses.test.ts

@@ -1,104 +0,0 @@
-import { RecentAddressesStore, setupRecentAddressesStore, getRecentAddressesStore } from ".";
-import { RECENT_ADDRESSES_COUNT_LIMIT } from "./recentAddresses";
-
-describe("RecentAddressesStore", () => {
-  const onAddAddressCompleteMock = jest.fn();
-  let store: RecentAddressesStore;
-
-  beforeEach(() => {
-    onAddAddressCompleteMock.mockClear();
-    setupRecentAddressesStore({}, onAddAddressCompleteMock);
-    store = getRecentAddressesStore();
-  });
-
-  it("should add one address and return this only address", async () => {
-    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
-    await store.addAddress("ethereum", newAddress);
-    const addresses = store.getAddresses("ethereum");
-    expect(addresses).toEqual([newAddress]);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
-  });
-
-  it("should add a second address and return addresses sorted by insertion", async () => {
-    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
-    await store.addAddress("ethereum", newAddress);
-    let addresses = store.getAddresses("ethereum");
-    expect(addresses).toEqual([newAddress]);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
-
-    const newAddress2 = "0xB69B37A4Fb4A18b3258f974ff6e9f529AD2647b1";
-    await store.addAddress("ethereum", newAddress2);
-    addresses = store.getAddresses("ethereum");
-    expect(addresses).toEqual([newAddress2, newAddress]);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(2);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress2, newAddress] });
-  });
-
-  it("should replace at first place when an address is already saved", async () => {
-    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
-    await store.addAddress("ethereum", newAddress);
-    let addresses = store.getAddresses("ethereum");
-    expect(addresses).toEqual([newAddress]);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
-
-    const newAddress2 = "0xB69B37A4Fb4A18b3258f974ff6e9f529AD2647b1";
-    await store.addAddress("ethereum", newAddress2);
-    addresses = store.getAddresses("ethereum");
-    expect(addresses).toEqual([newAddress2, newAddress]);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(2);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress2, newAddress] });
-
-    await store.addAddress("ethereum", newAddress);
-    addresses = store.getAddresses("ethereum");
-    expect(addresses).toEqual([newAddress, newAddress2]);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(3);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress, newAddress2] });
-  });
-
-  it("should replace at first place and remove last element when addresses exceed count limit", async () => {
-    let expectedAddresses: string[] = [];
-    for (let index = 0; index < RECENT_ADDRESSES_COUNT_LIMIT; index++) {
-      await store.addAddress("ethereum", `0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3${index}`);
-      expectedAddresses.unshift(`0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3${index}`);
-    }
-
-    let addresses = store.getAddresses("ethereum");
-    expect(addresses).toEqual(expectedAddresses);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(RECENT_ADDRESSES_COUNT_LIMIT);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: expectedAddresses });
-
-    const newAddress2 = "0xB69B37A4Fb4A18b3258f974ff6e9f529AD2647b1";
-    expectedAddresses.splice(expectedAddresses.length - 1, 1);
-    expectedAddresses = [newAddress2, ...expectedAddresses];
-
-    await store.addAddress("ethereum", newAddress2);
-    addresses = store.getAddresses("ethereum");
-    expect(addresses).toEqual(expectedAddresses);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(RECENT_ADDRESSES_COUNT_LIMIT + 1);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: expectedAddresses });
-  });
-
-  it("should add an address of a different currency", async () => {
-    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
-    await store.addAddress("ethereum", newAddress);
-
-    let addresses = store.getAddresses("ethereum");
-    expect(addresses).toEqual([newAddress]);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
-
-    const newAddress2 = "bc1pxlmrudqyq8qd8pfsc4mpmlaw56x6vtcr9m8nvp8kj3gckefc4kmqhkg4l7";
-    await store.addAddress("bitcoin", newAddress2);
-
-    addresses = store.getAddresses("bitcoin");
-    expect(addresses).toEqual([newAddress2]);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(2);
-    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({
-      ethereum: [newAddress],
-      bitcoin: [newAddress2],
-    });
-  });
-});

package/src/account/recentAddresses.ts

@@ -1,84 +0,0 @@
-export const RECENT_ADDRESSES_COUNT_LIMIT = 12;
-
-export type RecentAddressesCache = Record<string, string[]>;
-
-export interface RecentAddressesStore {
-  addAddress(currency: string, address: string): void;
-  syncAddresses(cache: RecentAddressesCache): void;
-  getAddresses(currency: string): string[];
-}
-
-type CallbackMode = "triggerCallback" | "skipCallback";
-
-let recentAddressesStore: RecentAddressesStore | null = null;
-
-export function getRecentAddressesStore(): RecentAddressesStore {
-  if (recentAddressesStore === null) {
-    throw new Error(
-      "Recent addresses store instance is null, please call function setupRecentAddressesStore in application initialization",
-    );
-  }
-  return recentAddressesStore;
-}
-
-export function setupRecentAddressesStore(
-  addressesByCurrency: RecentAddressesCache,
-  onAddAddressComplete: (addressesByCurrency: RecentAddressesCache) => void,
-): void {
-  recentAddressesStore = new RecentAddressesStoreImpl(addressesByCurrency, onAddAddressComplete);
-}
-
-class RecentAddressesStoreImpl implements RecentAddressesStore {
-  private addressesByCurrency: RecentAddressesCache = {};
-  private readonly onAddAddressComplete: (addressesByCurrency: Record<string, string[]>) => void;
-
-  constructor(
-    addressesByCurrency: RecentAddressesCache,
-    onAddAddressComplete: (addressesByCurrency: RecentAddressesCache) => void,
-  ) {
-    this.addressesByCurrency = { ...addressesByCurrency };
-    this.onAddAddressComplete = onAddAddressComplete;
-  }
-
-  addAddress(currency: string, address: string): void {
-    this.addAddressToCache(currency, address, "triggerCallback");
-  }
-
-  syncAddresses(cache: RecentAddressesCache): void {
-    const previousAddresses = { ...this.addressesByCurrency };
-    this.addressesByCurrency = { ...cache };
-    for (const currency in previousAddresses) {
-      for (const address of previousAddresses[currency]) {
-        this.addAddressToCache(currency, address, "skipCallback");
-      }
-    }
-
-    this.onAddAddressComplete(this.addressesByCurrency);
-  }
-
-  getAddresses(currency: string): string[] {
-    const addresses = this.addressesByCurrency[currency];
-    return addresses ?? [];
-  }
-
-  private addAddressToCache(currency: string, address: string, callbackMode: CallbackMode): void {
-    if (!this.addressesByCurrency[currency]) {
-      this.addressesByCurrency[currency] = [];
-    }
-
-    const addresses = this.addressesByCurrency[currency];
-    const addressIndex = addresses.indexOf(address);
-    if (addressIndex !== -1) {
-      addresses.splice(addressIndex, 1);
-    } else if (addresses.length >= RECENT_ADDRESSES_COUNT_LIMIT) {
-      addresses.pop();
-    }
-
-    addresses.unshift(address);
-    this.addressesByCurrency[currency] = [...addresses];
-
-    if (callbackMode === "triggerCallback") {
-      this.onAddAddressComplete(this.addressesByCurrency);
-    }
-  }
-}

package/src/bridge/generic-alpaca/postSync.test.ts

@@ -1,97 +0,0 @@
-import type { Account } from "@ledgerhq/types-live";
-import { postSync } from "./postSync";
-import BigNumber from "bignumber.js";
-
-describe("postSync", () => {
-  it("removes confirmed and outdated native operations from the pending pool", () => {
-    const initialAccount = {
-      operations: [{ hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" }],
-      pendingOperations: [
-        { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "IN" },
-        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "OUT" },
-        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
-      ],
-    } as Account;
-    const synced = {
-      operations: [
-        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "OUT" },
-        { hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" },
-      ],
-      pendingOperations: [
-        { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "IN" },
-        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "OUT" },
-        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
-      ],
-    } as Account;
-
-    expect(postSync(initialAccount, synced)).toMatchObject({
-      operations: [
-        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "OUT" },
-        { hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" },
-      ],
-      pendingOperations: [
-        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
-      ],
-    });
-  });
-
-  it("removes confirmed and outdated token operations from the pending pool", () => {
-    const initialAccount = {
-      operations: [{ hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" }],
-      pendingOperations: [
-        { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "NONE" },
-        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "FEES" },
-        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
-      ],
-      subAccounts: [
-        {
-          pendingOperations: [
-            { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "IN" },
-            { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "FEES" },
-          ],
-        },
-      ],
-    } as Account;
-    const synced = {
-      operations: [
-        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "FEES" },
-        { hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" },
-      ],
-      pendingOperations: [
-        { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "NONE" },
-        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "FEES" },
-        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
-      ],
-      subAccounts: [
-        {
-          operations: [{ hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "OUT" }],
-          pendingOperations: [
-            { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "IN" },
-          ],
-        },
-      ],
-    } as Account;
-
-    expect(postSync(initialAccount, synced)).toMatchObject({
-      operations: [
-        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "FEES" },
-        { hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" },
-      ],
-      pendingOperations: [
-        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
-      ],
-      subAccounts: [
-        {
-          operations: [
-            {
-              hash: "hash1",
-              transactionSequenceNumber: new BigNumber(5),
-              type: "OUT",
-            },
-          ],
-          pendingOperations: [],
-        },
-      ],
-    });
-  });
-});

package/src/bridge/generic-alpaca/postSync.ts

@@ -1,42 +0,0 @@
-import type { Account, AccountLike, Operation } from "@ledgerhq/types-live";
-import BigNumber from "bignumber.js";
-
-/**
- * After each sync or scan, remove operations from the pending pools if necessary
- * Operations stay pending if and only if
- *  - they are confirmed, i.e. their hash appear in the operation list
- *  - they are not outdated, i.e. their sequence number is at least greater than the
- *    sequence number of the latest transaction
- * NOTE Compared to the default behaviour
- *  - pending operations of token accounts are cleaned up, so we don't see both pending and completed
- *    sub operations in the operation details drawer
- *  - pending operations are cleaned if their hash already belong to the completed operations, preventing
- *    undesired replacement (ex: optimistic operation for self token sending on EVM is incomplete, since
- *    it only contains the OUT sub operation)
- */
-export function postSync(initial: Account, synced: Account): Account {
-  const lastOperation = synced.operations.find(op => ["OUT", "FEES"].includes(op.type));
-  const latestSequence = lastOperation?.transactionSequenceNumber || new BigNumber(-1);
-
-  function isPending(account: AccountLike, op: Operation): boolean {
-    return (
-      // Operation is not confirmed
-      !account.operations.some(o => o.hash === op.hash) &&
-      // Operation is not outdated
-      op.transactionSequenceNumber !== undefined &&
-      op.transactionSequenceNumber.gt(latestSequence)
-    );
-  }
-
-  const pendingOperations = initial.pendingOperations.length
-    ? initial.pendingOperations.filter(op => isPending(synced, op))
-    : [];
-  const subAccounts = synced.subAccounts?.length
-    ? synced.subAccounts.map(subAccount => ({
-        ...subAccount,
-        pendingOperations: subAccount.pendingOperations.filter(op => isPending(subAccount, op)),
-      }))
-    : [];
-
-  return { ...synced, pendingOperations, subAccounts };
-}

package/src/e2e/data/regexes.ts

@@ -1 +0,0 @@
-export const floatNumberRegex = /^\d+\.?\d+$/;

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