@ledgerhq/live-common 34.54.0-nightly.20251209023841 → 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/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+$/;