@ledgerhq/live-common 34.42.0-nightly.3 → 34.42.0

package/src/bridge/crypto-assets/index.test.ts

@@ -1,71 +0,0 @@
-import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import { getCryptoAssetsStore, setCryptoAssetsStore } from ".";
-import * as legacy from "@ledgerhq/cryptoassets/tokens";
-import { CryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/type";
-
-describe("Testing CryptoAssetStore", () => {
-  it("should return the default methods from cryptoassets libs when feature flag does not exists", () => {
-    LiveConfig.setConfig({
-      some_other_feature: {
-        type: "boolean",
-        default: true,
-      },
-    });
-
-    const store = getCryptoAssetsStore();
-    expect(store).toEqual({
-      findTokenByAddress: legacy.findTokenByAddress,
-      getTokenById: legacy.getTokenById,
-      findTokenById: legacy.findTokenById,
-      findTokenByAddressInCurrency: legacy.findTokenByAddressInCurrency,
-      findTokenByTicker: legacy.findTokenByTicker,
-    });
-  });
-
-  it("should return the default methods from cryptoassets libs when feature flag is disabled", () => {
-    LiveConfig.setConfig({
-      feature_cal_lazy_loading: {
-        type: "boolean",
-        default: false,
-      },
-    });
-
-    const store = getCryptoAssetsStore();
-    expect(store).toEqual({
-      findTokenByAddress: legacy.findTokenByAddress,
-      getTokenById: legacy.getTokenById,
-      findTokenById: legacy.findTokenById,
-      findTokenByAddressInCurrency: legacy.findTokenByAddressInCurrency,
-      findTokenByTicker: legacy.findTokenByTicker,
-    });
-  });
-
-  it("should throw an error when no store is set and feature flag is enabled", () => {
-    LiveConfig.setConfig({
-      feature_cal_lazy_loading: {
-        type: "boolean",
-        default: true,
-      },
-    });
-
-    expect(() => getCryptoAssetsStore()).toThrow(
-      "CryptoAssetsStore is not set. Please call setCryptoAssetsStore first.",
-    );
-  });
-
-  it("should throw return the new store when feature flag is enabled", () => {
-    LiveConfig.setConfig({
-      feature_cal_lazy_loading: {
-        type: "boolean",
-        default: true,
-      },
-    });
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const newStore = {} as unknown as CryptoAssetsStore;
-    setCryptoAssetsStore(newStore);
-
-    const store = getCryptoAssetsStore();
-    expect(store).toBe(newStore);
-  });
-});

package/src/bridge/crypto-assets/index.ts

@@ -1,30 +0,0 @@
-import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import { CryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/type";
-import * as legacy from "@ledgerhq/cryptoassets/tokens";
-
-let cryptoAssetsStore: CryptoAssetsStore | undefined = undefined;
-
-export function setCryptoAssetsStore(store: CryptoAssetsStore) {
-  cryptoAssetsStore = store;
-}
-
-const legacyStore: CryptoAssetsStore = {
-  findTokenByAddress: legacy.findTokenByAddress,
-  getTokenById: legacy.getTokenById,
-  findTokenById: legacy.findTokenById,
-  findTokenByAddressInCurrency: legacy.findTokenByAddressInCurrency,
-  findTokenByTicker: legacy.findTokenByTicker,
-};
-
-export function getCryptoAssetsStore(): CryptoAssetsStore {
-  const featureEnabled = LiveConfig.getValueByKey("feature_cal_lazy_loading");
-  if (!featureEnabled) {
-    return legacyStore;
-  }
-
-  if (!cryptoAssetsStore) {
-    throw new Error("CryptoAssetsStore is not set. Please call setCryptoAssetsStore first.");
-  }
-
-  return cryptoAssetsStore;
-}

package/src/e2e/families/osmosis.ts

@@ -1,13 +0,0 @@
-import { Delegate } from "../models/Delegate";
-import { containsSubstringInEvent, pressBoth, pressUntilTextFound, waitFor } from "../speculos";
-import { DeviceLabels } from "../enum/DeviceLabels";
-import expect from "expect";
-
-export async function delegateOsmosis(delegatingAccount: Delegate) {
-  await waitFor(DeviceLabels.PLEASE_REVIEW);
-  const events = await pressUntilTextFound(DeviceLabels.CAPS_APPROVE);
-  const amountInUosmo = (Number(delegatingAccount.amount) * 1_000_000).toString();
-  const isAmountCorrect = containsSubstringInEvent(amountInUosmo, events);
-  expect(isAmountCorrect).toBeTruthy();
-  await pressBoth();
-}

package/src/modularDrawer/__mocks__/currencies.mock.ts

@@ -1,62 +0,0 @@
-import { getCryptoCurrencyById } from "@ledgerhq/live-common/currencies/index";
-import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-
-export const mockBtcCryptoCurrency = getCryptoCurrencyById("bitcoin");
-export const mockEthCryptoCurrency = getCryptoCurrencyById("ethereum");
-export const mockArbitrumCryptoCurrency = getCryptoCurrencyById("arbitrum");
-export const mockBaseCryptoCurrency = getCryptoCurrencyById("base");
-export const mockScrollCryptoCurrency = getCryptoCurrencyById("scroll");
-export const mockInjectiveCryptoCurrency = getCryptoCurrencyById("injective");
-
-export const arbitrumToken: TokenCurrency = {
-  type: "TokenCurrency",
-  id: "arbitrum/erc20/arbitrum",
-  contractAddress: "0x912CE59144191C1204E64559FE8253a0e49E6548",
-  parentCurrency: mockArbitrumCryptoCurrency,
-  tokenType: "erc20",
-  name: "Arbitrum",
-  ticker: "ARB",
-  units: [
-    {
-      name: "Arbitrum",
-      code: "ARB",
-      magnitude: 18,
-    },
-  ],
-};
-export const usdcToken: TokenCurrency = {
-  type: "TokenCurrency",
-  id: "ethereum/erc20/usd__coin",
-  contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-  parentCurrency: mockEthCryptoCurrency,
-  tokenType: "erc20",
-  name: "USD Coin",
-  ticker: "USDC",
-  units: [
-    {
-      name: "USD Coin",
-      code: "USDC",
-      magnitude: 6,
-    },
-  ],
-};
-
-export const findCryptoCurrencyById = (id: string) =>
-  [mockBtcCryptoCurrency, mockEthCryptoCurrency, mockArbitrumCryptoCurrency].find(a => a.id === id);
-export const getTokenOrCryptoCurrencyById = (id: string) =>
-  [
-    mockBtcCryptoCurrency,
-    mockEthCryptoCurrency,
-    mockArbitrumCryptoCurrency,
-    arbitrumToken,
-    usdcToken,
-  ].find(a => a.id === id);
-
-export const mockCurrenciesByProvider = [
-  {
-    providerId: "ethereum",
-    currenciesByNetwork: [mockEthCryptoCurrency],
-  },
-];
-
-export const mockCurrencyIds = ["bitcoin", "ethereum", "arbitrum", "base"];

package/src/modularDrawer/__mocks__/useGroupedCurrenciesByProvider.mock.ts

@@ -1,49 +0,0 @@
-import { LoadingStatus } from "@ledgerhq/live-common/deposit/type";
-import {
-  arbitrumToken,
-  mockArbitrumCryptoCurrency,
-  mockBaseCryptoCurrency,
-  mockBtcCryptoCurrency,
-  mockEthCryptoCurrency,
-  mockInjectiveCryptoCurrency,
-  mockScrollCryptoCurrency,
-  usdcToken,
-} from "./currencies.mock";
-
-export const providers = [
-  {
-    providerId: "bitcoin",
-    currenciesByNetwork: [mockBtcCryptoCurrency],
-  },
-  {
-    providerId: "ethereum",
-    currenciesByNetwork: [
-      mockEthCryptoCurrency,
-      mockArbitrumCryptoCurrency,
-      mockBaseCryptoCurrency,
-      mockScrollCryptoCurrency,
-    ],
-  },
-  { providerId: "arbitrum", currenciesByNetwork: [arbitrumToken] },
-  { providerId: "usd-coin", currenciesByNetwork: [usdcToken] },
-  { providerId: "injective-protocol", currenciesByNetwork: [mockInjectiveCryptoCurrency] },
-];
-
-export const res = {
-  result: {
-    currenciesByProvider: providers,
-    sortedCryptoCurrencies: [
-      mockBtcCryptoCurrency,
-      mockEthCryptoCurrency,
-      mockArbitrumCryptoCurrency,
-      mockBaseCryptoCurrency,
-      mockScrollCryptoCurrency,
-      mockInjectiveCryptoCurrency,
-    ],
-  },
-};
-
-export const useGroupedCurrenciesByProvider: jest.Mock = jest.fn(() => ({
-  ...res,
-  loadingStatus: LoadingStatus.Success,
-}));

package/src/modularDrawer/utils/__tests__/haveOneCommonProvider.test.ts

@@ -1,34 +0,0 @@
-import { haveOneCommonProvider } from "../haveOneCommonProvider";
-import { useGroupedCurrenciesByProvider } from "../../__mocks__/useGroupedCurrenciesByProvider.mock";
-import { LoadingBasedGroupedCurrencies } from "@ledgerhq/live-common/deposit/type";
-
-jest.mock("@ledgerhq/live-common/deposit/useGroupedCurrenciesByProvider.hook", () => ({
-  useGroupedCurrenciesByProvider: () => useGroupedCurrenciesByProvider(),
-}));
-
-describe("haveOneCommonProvider", () => {
-  it("should return false for an empty array", () => {
-    expect(haveOneCommonProvider([], [])).toBe(false);
-  });
-
-  it("should return true for a single currency with one provider", () => {
-    const { result } = useGroupedCurrenciesByProvider(true) as LoadingBasedGroupedCurrencies;
-    const { currenciesByProvider } = result;
-
-    expect(haveOneCommonProvider(["bitcoin"], currenciesByProvider)).toBe(true);
-  });
-
-  it("should return false for multiple currencies with different providers", () => {
-    const { result } = useGroupedCurrenciesByProvider(true) as LoadingBasedGroupedCurrencies;
-    const { currenciesByProvider } = result;
-
-    expect(haveOneCommonProvider(["bitcoin", "ethereum"], currenciesByProvider)).toBe(false);
-  });
-
-  it("should return true for multiple currencies with the same provider", () => {
-    const { result } = useGroupedCurrenciesByProvider(true) as LoadingBasedGroupedCurrencies;
-    const { currenciesByProvider } = result;
-
-    expect(haveOneCommonProvider(["ethereum", "arbitrum"], currenciesByProvider)).toBe(true);
-  });
-});

package/src/modularDrawer/utils/haveOneCommonProvider.ts

@@ -1,31 +0,0 @@
-import { CurrenciesByProviderId } from "@ledgerhq/live-common/deposit/type";
-
-/**
- * This function checks if all currencies in the provided array
- * it stopped at the first currency that does not match to prevent unnecessary iterations.
- *
- * @param currenciesIdsArray array of currency IDs to check
- * @param currenciesByProvider array of currencies grouped by provider
- * @returns boolean indicating whether all currencies in the array have one common provider
- */
-export const haveOneCommonProvider = (
-  currenciesIdsArray: string[],
-  currenciesByProvider: CurrenciesByProviderId[],
-): boolean => {
-  if (currenciesIdsArray.length === 0) return false;
-
-  const providerIds = new Set<string>();
-
-  for (const currencyId of currenciesIdsArray) {
-    for (const provider of currenciesByProvider) {
-      if (provider.currenciesByNetwork.some(currency => currency.id === currencyId)) {
-        providerIds.add(provider.providerId);
-        if (providerIds.size > 1) {
-          return false;
-        }
-      }
-    }
-  }
-
-  return true;
-};