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

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/domain/getTotalStakeableAssets.test.ts

@@ -1,267 +0,0 @@
-import { genAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
-import { getCryptoCurrencyById } from "../currencies/index";
-import { Account } from "@ledgerhq/types-live";
-import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import BigNumber from "bignumber.js";
-import { getTotalStakeableAssets } from "./getTotalStakeableAssets";
-import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
-
-// Setup mock store for unit tests
-setupMockCryptoAssetsStore();
-
-const ETH = getCryptoCurrencyById("ethereum");
-const BTC = getCryptoCurrencyById("bitcoin");
-
-// Create mock tokens for tests
-const ZRX_TOKEN: TokenCurrency = {
-  type: "TokenCurrency",
-  id: "ethereum/erc20/0x_project",
-  contractAddress: "0xE41d2489571d322189246DaFA5ebDe1F4699F498",
-  parentCurrency: ETH,
-  tokenType: "erc20",
-  name: "0x Project",
-  ticker: "ZRX",
-  delisted: false,
-  disableCountervalue: false,
-  units: [{ name: "ZRX", code: "ZRX", magnitude: 18 }],
-};
-
-const REP_TOKEN: TokenCurrency = {
-  type: "TokenCurrency",
-  id: "ethereum/erc20/augur",
-  contractAddress: "0x1985365e9f78359a9B6AD760e32412f4a445E862",
-  parentCurrency: ETH,
-  tokenType: "erc20",
-  name: "Augur",
-  ticker: "REP",
-  delisted: false,
-  disableCountervalue: false,
-  units: [{ name: "REP", code: "REP", magnitude: 18 }],
-};
-
-const mockedAccounts: Account[] = [
-  genAccount("mocked-account-1", {
-    currency: ETH,
-    tokensData: [ZRX_TOKEN, REP_TOKEN],
-  }),
-];
-
-describe("getTotalStakeableAssets", () => {
-  it("should return empty Set if no accounts", () => {
-    const result = getTotalStakeableAssets([], [], []);
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(0);
-    expect(result.stakeableAssets).toEqual([]);
-  });
-
-  it("should return empty Set if accounts is null", () => {
-    const result = getTotalStakeableAssets(null, [], []);
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(0);
-    expect(result.stakeableAssets).toEqual([]);
-  });
-
-  it("should return empty Set if accounts is undefined", () => {
-    const result = getTotalStakeableAssets(undefined, [], []);
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(0);
-    expect(result.stakeableAssets).toEqual([]);
-  });
-
-  it("should return empty Set if no staking currencies enabled", () => {
-    const result = getTotalStakeableAssets(mockedAccounts, [], []);
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(0);
-    expect(result.stakeableAssets).toEqual([]);
-  });
-
-  it("should return Set with matching currency ID when staking currency is enabled", () => {
-    const account = mockedAccounts[0];
-    const stakingCurrenciesEnabled = [ETH.id]; // "ethereum"
-
-    expect(account.balance).toBeTruthy();
-    expect(account.balance instanceof BigNumber).toBe(true);
-    expect(account.balance.gt(0)).toBe(true);
-
-    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
-
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(1);
-    expect(result.combinedIds.has(ETH.id)).toBe(true);
-    expect(result.stakeableAssets.length).toBe(1);
-    expect(result.stakeableAssets[0]).toEqual({
-      ticker: ETH.ticker,
-      networkName: ETH.name,
-      id: ETH.id,
-    });
-  });
-
-  it("should return Set with matching token IDs when staking tokens are enabled", () => {
-    const account = mockedAccounts[0];
-    const stakingCurrenciesEnabled = [ZRX_TOKEN.id, REP_TOKEN.id];
-
-    expect(account.subAccounts).toBeDefined();
-    expect(account.subAccounts?.length).toBe(2);
-
-    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
-
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(2);
-    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
-    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(true);
-    expect(result.stakeableAssets.length).toBe(2);
-    expect(result.stakeableAssets).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
-        expect.objectContaining({ id: REP_TOKEN.id, ticker: REP_TOKEN.ticker }),
-      ]),
-    );
-  });
-
-  it("should return Set with both currency and token IDs when both are enabled", () => {
-    const account = mockedAccounts[0];
-    const stakingCurrenciesEnabled = [ETH.id, ZRX_TOKEN.id, REP_TOKEN.id];
-
-    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
-
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(3);
-    expect(result.combinedIds.has(ETH.id)).toBe(true);
-    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
-    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(true);
-    expect(result.stakeableAssets.length).toBe(3);
-    expect(result.stakeableAssets).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
-        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
-        expect.objectContaining({ id: REP_TOKEN.id, ticker: REP_TOKEN.ticker }),
-      ]),
-    );
-  });
-
-  it("should filter out currencies without funds", () => {
-    const account = mockedAccounts[0];
-    const accountWithZeroBalance = { ...account, balance: new BigNumber(0) };
-    const stakingCurrenciesEnabled = [ETH.id];
-
-    const result = getTotalStakeableAssets([accountWithZeroBalance], stakingCurrenciesEnabled, []);
-
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(0);
-    expect(result.stakeableAssets).toEqual([]);
-  });
-
-  it("should filter out tokens without funds", () => {
-    const account = mockedAccounts[0];
-    const [zrxAccount, repAccount] = account.subAccounts || [];
-    const emptyRepAccount = { ...repAccount, balance: new BigNumber(0) };
-    const accountWithEmptyToken = { ...account, subAccounts: [zrxAccount, emptyRepAccount] };
-    const stakingCurrenciesEnabled = [ZRX_TOKEN.id, REP_TOKEN.id];
-
-    const result = getTotalStakeableAssets([accountWithEmptyToken], stakingCurrenciesEnabled, []);
-
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(1);
-    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
-    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(false);
-    expect(result.stakeableAssets.length).toBe(1);
-    expect(result.stakeableAssets[0]).toEqual(
-      expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
-    );
-  });
-
-  it("should include partner staking currencies enabled", () => {
-    const account = mockedAccounts[0];
-    const stakingCurrenciesEnabled = [ETH.id];
-    const partnerStakingCurrenciesEnabled = [ZRX_TOKEN.id];
-
-    const result = getTotalStakeableAssets(
-      [account],
-      stakingCurrenciesEnabled,
-      partnerStakingCurrenciesEnabled,
-    );
-
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(2);
-    expect(result.combinedIds.has(ETH.id)).toBe(true);
-    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
-    expect(result.stakeableAssets.length).toBe(2);
-    expect(result.stakeableAssets).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
-        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
-      ]),
-    );
-  });
-
-  it("should deduplicate IDs when same currency appears in both lists", () => {
-    const account = mockedAccounts[0];
-    const stakingCurrenciesEnabled = [ETH.id];
-    const partnerStakingCurrenciesEnabled = [ETH.id]; // Same currency
-
-    const result = getTotalStakeableAssets(
-      [account],
-      stakingCurrenciesEnabled,
-      partnerStakingCurrenciesEnabled,
-    );
-
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(1);
-    expect(result.combinedIds.has(ETH.id)).toBe(true);
-    expect(result.stakeableAssets.length).toBe(1);
-    expect(result.stakeableAssets[0]).toEqual({
-      ticker: ETH.ticker,
-      networkName: ETH.name,
-      id: ETH.id,
-    });
-  });
-
-  it("should handle multiple accounts with different currencies", () => {
-    const ethAccount = mockedAccounts[0];
-    const btcAccount = genAccount("mocked-account-2", {
-      currency: BTC,
-    });
-    const accounts = [ethAccount, btcAccount];
-    const stakingCurrenciesEnabled = [ETH.id, BTC.id];
-
-    const result = getTotalStakeableAssets(accounts, stakingCurrenciesEnabled, []);
-
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(2);
-    expect(result.combinedIds.has(ETH.id)).toBe(true);
-    expect(result.combinedIds.has(BTC.id)).toBe(true);
-    expect(result.stakeableAssets.length).toBe(2);
-    expect(result.stakeableAssets).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
-        expect.objectContaining({ id: BTC.id, ticker: BTC.ticker }),
-      ]),
-    );
-  });
-
-  it("should only include IDs that match staking currencies enabled", () => {
-    const account = mockedAccounts[0];
-    const stakingCurrenciesEnabled = [ZRX_TOKEN.id]; // Only ZRX enabled, not ETH or REP
-
-    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
-
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(1);
-    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
-    expect(result.combinedIds.has(ETH.id)).toBe(false);
-    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(false);
-    expect(result.stakeableAssets.length).toBe(1);
-    expect(result.stakeableAssets[0]).toEqual(
-      expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
-    );
-  });
-
-  it("should handle empty arrays for staking currencies", () => {
-    const account = mockedAccounts[0];
-    const result = getTotalStakeableAssets([account], [], []);
-
-    expect(result.combinedIds).toBeInstanceOf(Set);
-    expect(result.combinedIds.size).toBe(0);
-    expect(result.stakeableAssets).toEqual([]);
-  });
-});

package/src/domain/getTotalStakeableAssets.ts

@@ -1,47 +0,0 @@
-import { getTokensWithFundsMap } from "./getTokensWithFunds";
-import { Account } from "@ledgerhq/types-live";
-
-export function getTotalStakeableAssets(
-  accounts: Account[] | null | undefined,
-  stakingCurrenciesEnabled: string[],
-  partnerStakingCurrenciesEnabled: string[],
-): {
-  combinedIds: Set<string>;
-  stakeableAssets: { ticker: string; networkName: string; id: string }[];
-} {
-  if (!accounts) return { combinedIds: new Set<string>(), stakeableAssets: [] };
-
-  const accountsWithFundsCurrencies = accounts
-    .filter(account => account?.balance.isGreaterThan(0))
-    .map(account => account?.currency);
-
-  const allStakingCurrenciesEnabled = new Set([
-    ...stakingCurrenciesEnabled,
-    ...partnerStakingCurrenciesEnabled,
-  ]);
-
-  const tokenWithFundsMap = getTokensWithFundsMap(accounts);
-  const filteredAccountCurrencyIds = [...accountsWithFundsCurrencies].filter(currency =>
-    allStakingCurrenciesEnabled.has(currency.id),
-  );
-  const filteredTokenWithFunds = [...tokenWithFundsMap.values()].filter(token =>
-    allStakingCurrenciesEnabled.has(token.id),
-  );
-
-  const combined = new Map<string, { ticker: string; networkName: string; id: string }>();
-  for (const currency of filteredAccountCurrencyIds) {
-    combined.set(currency.id, {
-      ticker: currency.ticker,
-      networkName: currency.name,
-      id: currency.id,
-    });
-  }
-  for (const token of filteredTokenWithFunds) {
-    combined.set(token.id, token);
-  }
-
-  return {
-    combinedIds: new Set(Array.from(combined.values(), details => details.id)),
-    stakeableAssets: Array.from(combined.values()),
-  };
-}

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