@ledgerhq/live-common 34.2.0 → 34.3.0-next.0

package/src/currencies/formatShort.ts

@@ -0,0 +1,24 @@
+import numeral from "numeral";
+import { BigNumber } from "bignumber.js";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+
+/**
+ * This will format in a very concise way a valid, typically to be used on axis.
+ * For instance 15k 20k ,...
+ */
+export function formatShort(unit: Unit, value: BigNumber): string {
+  const { magnitude } = unit;
+  const floatValue = value.div(new BigNumber(10).pow(magnitude));
+
+  if (floatValue.isZero()) {
+    return "0";
+  }
+
+  if (new BigNumber(-1).isLessThan(floatValue) && floatValue.isLessThan(1)) {
+    // numeral have issues with low values, fallback on formatCurrencyUnit
+    return formatCurrencyUnit(unit, value);
+  }
+
+  return numeral(floatValue.toNumber()).format("0[.]0a");
+}

package/src/currencies/index.ts

@@ -1,4 +1,4 @@
-import {
+export {
   listFiatCurrencies,
   findFiatCurrencyByTicker,
   getFiatCurrencyByTicker,
@@ -22,61 +22,23 @@ import {
   getTokenById,
   addTokens,
 } from "@ledgerhq/cryptoassets";
-import {
+export {
   encodeURIScheme,
   decodeURIScheme,
   sanitizeValueString,
-  chopCurrencyUnitDecimals,
   formatCurrencyUnit,
-  formatCurrencyUnitFragment,
-  formatShort,
-  valueFromUnit,
+  type formatCurrencyUnitOptions,
   findCurrencyByTicker,
-} from "@ledgerhq/coin-framework/currencies/index";
-import { getCurrencyColor, ColorableCurrency } from "./color";
-import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
-import { sortCurrenciesByIds, currenciesByMarketcap } from "./sortByMarketcap";
+  parseCurrencyUnit,
+  toLocaleString,
+  isCurrencySupported,
+  listSupportedCurrencies,
+  setSupportedCurrencies,
+} from "@ledgerhq/coin-framework/currencies";
 
-export * from "@ledgerhq/coin-framework/currencies/BigNumberToLocaleString";
-export * from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
-export * from "@ledgerhq/coin-framework/currencies/support";
+export { getCurrencyColor, ColorableCurrency } from "./color";
+export { formatShort } from "./formatShort";
 export * from "./helpers";
-
-export {
-  sortCurrenciesByIds,
-  currenciesByMarketcap,
-  listFiatCurrencies,
-  listCryptoCurrencies,
-  getFiatCurrencyByTicker,
-  findCurrencyByTicker,
-  findCryptoCurrency,
-  findCryptoCurrencyById,
-  findCryptoCurrencyByTicker,
-  findCryptoCurrencyByScheme,
-  findCryptoCurrencyByKeyword,
-  findFiatCurrencyByTicker,
-  hasFiatCurrencyTicker,
-  listTokensForCryptoCurrency,
-  listTokenTypesForCryptoCurrency,
-  findTokenByAddress,
-  findTokenByTicker,
-  findTokenById,
-  hasTokenId,
-  getTokenById,
-  getAbandonSeedAddress,
-  parseCurrencyUnit,
-  chopCurrencyUnitDecimals,
-  formatCurrencyUnit,
-  formatCurrencyUnitFragment,
-  formatShort,
-  getCryptoCurrencyById,
-  hasCryptoCurrencyId,
-  encodeURIScheme,
-  decodeURIScheme,
-  valueFromUnit,
-  sanitizeValueString,
-  getCurrencyColor,
-  ColorableCurrency,
-  listTokens,
-  addTokens,
-};
+export { sortCurrenciesByIds, currenciesByMarketcap } from "./sortByMarketcap";
+export { listSupportedFiats } from "./support";
+export { valueFromUnit } from "./valueFromUnit";

package/src/currencies/support.ts

@@ -0,0 +1,98 @@
+import { getFiatCurrencyByTicker, hasFiatCurrencyTicker } from "@ledgerhq/cryptoassets";
+import { FiatCurrency } from "@ledgerhq/types-cryptoassets";
+import { getEnv } from "@ledgerhq/live-env";
+import { log } from "@ledgerhq/logs";
+
+let userSupportedFiats: FiatCurrency[] | null = null;
+
+// The API returns Coingeko countervalues tickers, but getFiatCurrencyByTicker might not support each of those.
+const locallySupportedFiats = [
+  "AED",
+  "AUD",
+  "BHD",
+  "BRL",
+  "CAD",
+  "CHF",
+  "CLP",
+  "CNY",
+  "CZK",
+  "DKK",
+  "EUR",
+  "GBP",
+  "HKD",
+  "HUF",
+  "IDR",
+  "ILS",
+  "INR",
+  "JPY",
+  "KRW",
+  "MXN",
+  "MYR",
+  "NGN",
+  "NOK",
+  "NZD",
+  "PHP",
+  "PKR",
+  "PLN",
+  "RUB",
+  "SEK",
+  "SGD",
+  "THB",
+  "TRY",
+  "UAH",
+  "USD",
+  "VND",
+  "ZAR",
+];
+
+async function initializeUserSupportedFiats() {
+  const remoteSupportedTokens = await fetchSupportedFiatsTokens();
+  let supportedTokens = [] as string[];
+
+  if (remoteSupportedTokens.length !== 0) {
+    remoteSupportedTokens.forEach(token => {
+      if (hasFiatCurrencyTicker(token)) {
+        supportedTokens.push(token);
+      }
+    });
+  } else {
+    supportedTokens = locallySupportedFiats;
+  }
+  userSupportedFiats = supportedTokens.map(getFiatCurrencyByTicker);
+}
+
+async function fetchSupportedFiatsTokens(): Promise<string[]> {
+  try {
+    const response = await fetch(`${getEnv("LEDGER_COUNTERVALUES_API")}/v3/supported/fiat`, {
+      method: "GET",
+      headers: {
+        accept: "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Request failed with status ${response.status}`);
+    }
+
+    const data: string[] = await response.json();
+    return data;
+  } catch (error) {
+    log("debug", `Failed to fetch supported fiat tokens. Error Message: ${error}`);
+    return [];
+  }
+}
+
+export async function listSupportedFiats(): Promise<FiatCurrency[]> {
+  if (userSupportedFiats === null) {
+    // Handle case where userSupportedFiats is not yet populated (e.g., by calling initializeUserSupportedFiats)
+    try {
+      await initializeUserSupportedFiats();
+    } catch (error) {
+      // Handle initialization error
+      log("debug", `Failed to initialize userSupportedFiats. Error Message: ${error}`);
+      return userSupportedFiats || [];
+    }
+    return userSupportedFiats || [];
+  }
+  return userSupportedFiats;
+}

package/src/currencies/valueFromUnit.ts

@@ -0,0 +1,10 @@
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+import { BigNumber } from "bignumber.js";
+
+/**
+ * convert a value in a given unit to a normalized value
+ * For instance, for 1 BTC, valueFromUnit(1, btcUnit) returns 100000000
+ * @memberof countervalue
+ */
+export const valueFromUnit = (valueInUnit: BigNumber, unit: Unit) =>
+  valueInUnit.times(new BigNumber(10).pow(unit.magnitude));

package/src/deviceSDK/actions/getLatestAvailableFirmware.test.ts

@@ -1,5 +1,5 @@
 import { Observable, of } from "rxjs";
-import { LockedDeviceError, TransportPendingOperation } from "@ledgerhq/errors";
+import { LockedDeviceError, TransportRaceCondition } from "@ledgerhq/errors";
 import { DeviceInfo, FirmwareUpdateContext } from "@ledgerhq/types-live";
 
 import { getDeviceInfoTask, internalGetDeviceInfoTask } from "../tasks/getDeviceInfo";
@@ -249,9 +249,9 @@ describe("getLatestAvailableFirmwareAction", () => {
         new Observable(o => {
           if (count < 1) {
             count++;
-            // Mocks the internal task, some shared error are thrown (like `TransportPendingOperation`)
+            // Mocks the internal task, some shared error are thrown (like `TransportRaceCondition`)
             // and caught by the `sharedLogicTaskWrapper`
-            o.error(new TransportPendingOperation());
+            o.error(new TransportRaceCondition());
           } else {
             o.next({ type: "data", deviceInfo: aDeviceInfo });
           }
@@ -291,7 +291,7 @@ describe("getLatestAvailableFirmwareAction", () => {
                 expect(error).toEqual(
                   expect.objectContaining({
                     type: "SharedError",
-                    name: "TransportPendingOperation",
+                    name: "TransportRaceCondition",
                     retrying: true,
                   }),
                 );

package/src/deviceSDK/commands/firmwareUpdate/installFirmware.ts

@@ -100,15 +100,15 @@ export function installFirmwareCommand(
               type: "firmwareInstallPermissionRequested",
             }
           : e.index === e.total
-          ? {
-              // the last APDU of the bulk part of the instalation means that the user validated
-              // the installation of the OSU firmware
-              type: "firmwareInstallPermissionGranted",
-            }
-          : {
-              type: "progress",
-              progress: e.progress,
-            };
+            ? {
+                // the last APDU of the bulk part of the instalation means that the user validated
+                // the installation of the OSU firmware
+                type: "firmwareInstallPermissionGranted",
+              }
+            : {
+                type: "progress",
+                progress: e.progress,
+              };
       }
       // then type is "device-permission-requested"
       return { type: "allowSecureChannelRequested" };

package/src/deviceSDK/commands/getBatteryStatus.ts

@@ -64,8 +64,8 @@ export function getBatteryStatus({
                   charging: chargingQi
                     ? ChargingModes.QI
                     : chargingUSB
-                    ? ChargingModes.USB
-                    : ChargingModes.NONE,
+                      ? ChargingModes.USB
+                      : ChargingModes.NONE,
                   issueCharging: !!(flags & FlagMasks.ISSUE_CHARGING),
                   issueTemperature: !!(flags & FlagMasks.ISSUE_TEMPERATURE),
                   issueBattery: !!(flags & FlagMasks.ISSUE_BATTERY),

package/src/deviceSDK/tasks/core.ts

@@ -2,7 +2,7 @@ import {
   CantOpenDevice,
   DisconnectedDevice,
   LockedDeviceError,
-  TransportPendingOperation,
+  TransportRaceCondition,
   UnresponsiveDeviceError,
   TransportStatusErrorClassType,
   CustomErrorClassType,
@@ -49,7 +49,7 @@ export function sharedLogicTaskWrapper<TaskArgsType, TaskEventsType>(
                 error instanceof UnresponsiveDeviceError ||
                 error instanceof CantOpenDevice ||
                 error instanceof DisconnectedDevice ||
-                error instanceof TransportPendingOperation
+                error instanceof TransportRaceCondition
               ) {
                 // Emits to the action an error event so it is aware of it (for ex locked device) before retrying
                 const event: SharedTaskEvent = {

package/src/errors.ts

@@ -29,13 +29,7 @@ export const LanguageInstallTimeout = createCustomErrorClass("LanguageInstallTim
 export const DeviceOnboarded = createCustomErrorClass("DeviceOnboarded");
 export const DeviceNotOnboarded = createCustomErrorClass("DeviceNotOnboarded");
 export const DeviceAlreadySetup = createCustomErrorClass("DeviceAlreadySetup");
-export const InvalidAddressBecauseAlreadyDelegated = createCustomErrorClass(
-  "InvalidAddressBecauseAlreadyDelegated",
-);
 
-export const AccountAwaitingSendPendingOperations = createCustomErrorClass(
-  "AccountAwaitingSendPendingOperations",
-);
 export const SourceHasMultiSign = createCustomErrorClass("SourceHasMultiSign");
 export const CosmosRedelegationInProgress = createCustomErrorClass("CosmosRedelegationInProgress");
 export const CosmosDelegateAllFundsWarning = createCustomErrorClass(
@@ -131,12 +125,13 @@ export const BluetoothNotSupportedError = createCustomErrorClass("FwUpdateBlueto
 export const EConnResetError = createCustomErrorClass("EConnReset");
 
 export { ClaimRewardsFeesWarning } from "@ledgerhq/errors";
+export * from "./families/stellar/errors";
 export * from "@ledgerhq/coin-framework/errors";
-export * from "@ledgerhq/coin-polkadot/errors";
 export * from "@ledgerhq/coin-algorand/errors";
-export * from "./families/stellar/errors";
-export * from "./families/solana/errors";
-export * from "./families/cardano/errors";
-export * from "@ledgerhq/coin-near/errors";
-export * from "@ledgerhq/coin-evm/errors";
 export * from "@ledgerhq/coin-bitcoin/errors";
+export * from "@ledgerhq/coin-cardano/errors";
+export * from "@ledgerhq/coin-evm/errors";
+export * from "@ledgerhq/coin-near/errors";
+export * from "@ledgerhq/coin-polkadot/errors";
+export * from "@ledgerhq/coin-solana/errors";
+export * from "@ledgerhq/coin-tezos/errors";

package/src/exchange/platform/startExchange.ts

@@ -13,16 +13,16 @@ const withDevicePromise = (deviceId, fn) =>
 const startExchange = (input: StartExchangeInput): Observable<ExchangeRequestEvent> => {
   return new Observable(o => {
     let unsubscribed = false;
-    const { deviceId, exchangeType, appVersion, provider } = input;
+    const { device, exchangeType, appVersion, provider } = input;
     const startExchangeAsync = async () => {
-      await withDevicePromise(deviceId, async transport => {
-        log("exchange", `attempt to connect to ${deviceId}`);
+      await withDevicePromise(device.deviceId, async transport => {
+        log("exchange", `attempt to connect to ${device.deviceId}`);
         let version;
         if (unsubscribed) return;
         if (provider) {
           switch (exchangeType) {
             case ExchangeTypes.Swap: {
-              const providerConfig = getSwapProvider(provider);
+              const providerConfig = await getSwapProvider(provider);
               if (providerConfig.type !== "CEX") {
                 throw new Error(`Unsupported provider type ${providerConfig.type}`);
               }
@@ -48,7 +48,7 @@ const startExchange = (input: StartExchangeInput): Observable<ExchangeRequestEve
         const nonce: string = await exchange.startNewTransaction();
         o.next({
           type: "start-exchange-result",
-          nonce,
+          startExchangeResult: { nonce, device },
         });
       });
     };
@@ -61,7 +61,7 @@ const startExchange = (input: StartExchangeInput): Observable<ExchangeRequestEve
       error => {
         o.next({
           type: "start-exchange-error",
-          error,
+          startExchangeError: { error, device },
         });
         o.complete();
         unsubscribed = true;

package/src/exchange/platform/transfer/completeExchange.ts

@@ -117,9 +117,7 @@ const completeExchange = (
           );
         } catch (e) {
           if (e instanceof TransportStatusError && e.statusCode === 0x6a83) {
-            throw new WrongDeviceForAccount(undefined, {
-              accountName: mainAccount.name,
-            });
+            throw new WrongDeviceForAccount();
           }
 
           throw convertTransportError(currentStep, e);

package/src/exchange/platform/types.ts

@@ -2,6 +2,7 @@ import type { Account, AccountLike, AccountRaw, AccountRawLike } from "@ledgerhq
 import { ExchangeTypes, RateTypes } from "@ledgerhq/hw-app-exchange";
 import type { Transaction } from "../../generated/types";
 import { ExchangeSwap } from "../swap/types";
+import { Device } from "../../hw/actions/types";
 
 export type CompleteExchangeRequestEvent =
   | { type: "complete-exchange" }
@@ -29,7 +30,7 @@ export type ExchangeSellRaw = {
 };
 
 export type StartExchangeInput = {
-  deviceId: string;
+  device: Device;
   exchangeType: number;
   appVersion?: string;
   provider?: string;

package/src/exchange/providers/swap.ts

@@ -8,9 +8,43 @@ export type SwapProviderConfig = {
 
 type CEXProviderConfig = ExchangeProviderNameAndSignature & SwapProviderConfig & { type: "CEX" };
 type DEXProviderConfig = SwapProviderConfig & { type: "DEX" };
+type AdditionalProviderConfig = SwapProviderConfig & { type: "DEX" | "CEX" } & {
+  version?: number;
+  needsBearerToken: boolean;
+  needsKYC: boolean;
+};
 export type ProviderConfig = CEXProviderConfig | DEXProviderConfig;
 
-const swapProviders: Record<string, ProviderConfig> = {
+const swapAdditionData: Record<string, AdditionalProviderConfig> = {
+  changelly: {
+    needsKYC: false,
+    needsBearerToken: false,
+    type: "CEX",
+  },
+  cic: {
+    needsKYC: false,
+    needsBearerToken: false,
+    type: "CEX",
+  },
+  moonpay: {
+    needsKYC: true,
+    needsBearerToken: false,
+    type: "CEX",
+    version: 2,
+  },
+  oneinch: {
+    type: "DEX",
+    needsKYC: false,
+    needsBearerToken: false,
+  },
+  paraswap: {
+    type: "DEX",
+    needsKYC: false,
+    needsBearerToken: false,
+  },
+};
+
+const swapProviders: Record<string, ProviderConfig & AdditionalProviderConfig> = {
   changelly: {
     name: "Changelly",
     publicKey: {
@@ -75,16 +109,97 @@ const swapProviders: Record<string, ProviderConfig> = {
   },
 };
 
-export const getSwapProvider = (providerName: string): ProviderConfig => {
-  const res = swapProviders[providerName.toLowerCase()];
+let providerDataCache: Record<string, ProviderConfig & AdditionalProviderConfig> | null = null;
+
+export const getSwapProvider = async (
+  providerName: string,
+): Promise<ProviderConfig & AdditionalProviderConfig> => {
+  const res = await fetchAndMergeProviderData();
 
-  if (!res) {
+  if (!res[providerName.toLowerCase()]) {
     throw new Error(`Unknown partner ${providerName}`);
   }
 
-  return res;
+  return res[providerName.toLowerCase()];
+};
+
+function transformData(providersData) {
+  const transformed = {};
+  providersData.forEach(provider => {
+    const key = provider.name.toLowerCase();
+    transformed[key] = {
+      name: provider.name,
+      publicKey: {
+        curve: provider.public_key_curve,
+        data: Buffer.from(provider.public_key, "hex"),
+      },
+      signature: Buffer.from(provider.signature, "hex"),
+    };
+  });
+  return transformed;
+}
+
+export const getProvidersData = async () => {
+  try {
+    const providersData = await (
+      await fetch(
+        "https://crypto-assets-service.api.aws.prd.ldg-tech.com/v1/partners?output=name,payload_signature_computed_format,signature,public_key,public_key_curve",
+      )
+    ).json();
+    return providersData;
+  } catch {
+    return swapProviders;
+  }
+};
+
+export const getProvidersCDNData = async () => {
+  try {
+    const providersData = await (
+      await fetch("https://cdn.live.ledger.com/swap-providers/data.json")
+    ).json();
+    return providersData;
+  } catch {
+    return swapAdditionData;
+  }
+};
+
+export const fetchAndMergeProviderData = async () => {
+  if (providerDataCache) {
+    return providerDataCache;
+  }
+
+  try {
+    const [providersData, providersExtraData] = await Promise.all([
+      getProvidersData(),
+      getProvidersCDNData(),
+    ]);
+
+    const transformedProvidersData = transformData(providersData);
+    const finalProvidersData = mergeProviderData(transformedProvidersData, providersExtraData);
+    providerDataCache = finalProvidersData;
+
+    return finalProvidersData;
+  } catch (error) {
+    console.error("Error fetching or processing provider data:", error);
+    const transformedProvidersData = transformData(swapProviders);
+    const finalProvidersData = mergeProviderData(transformedProvidersData, swapAdditionData);
+    providerDataCache = finalProvidersData;
+
+    return finalProvidersData;
+  }
 };
 
+function mergeProviderData(baseData, additionalData) {
+  const mergedData = { ...baseData };
+  Object.keys(additionalData).forEach(key => {
+    mergedData[key] = {
+      ...mergedData[key],
+      ...additionalData[key],
+    };
+  });
+  return mergedData;
+}
+
 export const getAvailableProviders = (): string[] => {
   if (isIntegrationTestEnv()) {
     return Object.keys(swapProviders).filter(p => p !== "changelly");

package/src/exchange/swap/api/v5/__tests__/fetchCurrencyAll.spec.ts

@@ -11,16 +11,15 @@ describe("fetchCurrencyAll", () => {
     (network as jest.Mock).mockImplementation(() => ({
       data: fetchCurrencyAllMock,
     }));
+    const providers = ["changelly", "cic", "moonpay", "oneinch", "paraswap"];
 
-    const result = await fetchCurrencyAll({
-      providers: ["oneinch"],
-    });
+    const result = await fetchCurrencyAll({ providers });
 
     expect(result).toStrictEqual(flattenV5CurrenciesAll(fetchCurrencyAllMock));
     expect(network as jest.Mock).toHaveBeenCalledWith({
       method: "GET",
       timeout: DEFAULT_SWAP_TIMEOUT_MS,
-      url: "https://swap.ledger.com/v5/currencies/all?providers-whitelist=oneinch&additional-coins-flag=false",
+      url: "https://swap.ledger.com/v5/currencies/all?providers-whitelist=changelly%2Ccic%2Cmoonpay%2Coneinch%2Cparaswap&additional-coins-flag=false",
     });
   });
 });

package/src/exchange/swap/api/v5/__tests__/fetchCurrencyFrom.spec.ts

@@ -12,16 +12,18 @@ describe("fetchCurrencyFrom", () => {
       data: fetchCurrencyFromMock,
     }));
 
+    const providers = ["changelly", "cic", "moonpay", "oneinch", "paraswap"];
+
     const result = await fetchCurrencyFrom({
-      providers: ["changelly", "cic", "oneinch"],
       currencyTo: "bitcoin",
+      providers,
     });
 
     expect(result).toStrictEqual(flattenV5CurrenciesToAndFrom(fetchCurrencyFromMock));
     expect(network as jest.Mock).toHaveBeenCalledWith({
       method: "GET",
       timeout: DEFAULT_SWAP_TIMEOUT_MS,
-      url: "https://swap.ledger.com/v5/currencies/from?providers-whitelist=changelly%2Ccic%2Coneinch&additional-coins-flag=false&currency-to=bitcoin",
+      url: "https://swap.ledger.com/v5/currencies/from?providers-whitelist=changelly%2Ccic%2Cmoonpay%2Coneinch%2Cparaswap&additional-coins-flag=false&currency-to=bitcoin",
     });
   });
 });

package/src/exchange/swap/api/v5/__tests__/fetchCurrencyTo.spec.ts

@@ -9,23 +9,23 @@ import { flattenV5CurrenciesToAndFrom } from "../../../utils/flattenV5Currencies
 jest.mock("@ledgerhq/live-network/network");
 
 const mockNetwork = network as jest.Mock;
+const providers = ["changelly", "cic", "moonpay", "oneinch", "paraswap"];
 
 describe("fetchCurrencyFrom", () => {
   it("success with 200", async () => {
     mockNetwork.mockReturnValueOnce({
       data: fetchCurrencyToMock,
     });
-
     const result = await fetchCurrencyTo({
-      providers: ["changelly", "cic", "oneinch"],
       currencyFromId: "bitcoin",
+      providers,
     });
 
     expect(result).toStrictEqual(flattenV5CurrenciesToAndFrom(fetchCurrencyToMock));
     expect(mockNetwork).toHaveBeenCalledWith({
       method: "GET",
       timeout: DEFAULT_SWAP_TIMEOUT_MS,
-      url: "https://swap.ledger.com/v5/currencies/to?providers-whitelist=changelly%2Ccic%2Coneinch&additional-coins-flag=false&currency-from=bitcoin",
+      url: "https://swap.ledger.com/v5/currencies/to?providers-whitelist=changelly%2Ccic%2Cmoonpay%2Coneinch%2Cparaswap&additional-coins-flag=false&currency-from=bitcoin",
     });
   });
 
@@ -34,8 +34,8 @@ describe("fetchCurrencyFrom", () => {
 
     try {
       await fetchCurrencyTo({
-        providers: ["changelly", "cic", "oneinch"],
         currencyFromId: "bitcoin",
+        providers,
       });
     } catch (e) {
       expect(e).toBeInstanceOf(LedgerAPI4xx);

package/src/exchange/swap/api/v5/fetchCurrencyAll.ts

@@ -6,12 +6,12 @@ import { fetchCurrencyAllMock } from "./__mocks__/fetchCurrencyAll.mocks";
 import { ResponseData as ResponseDataTo } from "./fetchCurrencyTo";
 import { ResponseData as ResponseDataFrom } from "./fetchCurrencyFrom";
 import { flattenV5CurrenciesAll } from "../../utils/flattenV5CurrenciesAll";
-import { getSwapAPIBaseURL } from "../..";
+import { getSwapAPIBaseURL, getSwapUserIP } from "../..";
 import { getEnv } from "@ledgerhq/live-env";
 
 type Props = {
-  providers: Array<string>;
   additionalCoinsFlag?: boolean;
+  providers: string[];
 };
 
 export type ResponseDataAll = {
@@ -26,12 +26,14 @@ export async function fetchCurrencyAll({ providers, additionalCoinsFlag = false
   const url = new URL(`${getSwapAPIBaseURL()}/currencies/all`);
   url.searchParams.append("providers-whitelist", providers.join(","));
   url.searchParams.append("additional-coins-flag", additionalCoinsFlag.toString());
+  const headers = getSwapUserIP();
 
   try {
     const { data } = await network<ResponseDataAll>({
       method: "GET",
       url: url.toString(),
       timeout: DEFAULT_SWAP_TIMEOUT_MS,
+      ...(headers !== undefined ? { headers } : {}),
     });
     return flattenV5CurrenciesAll(data);
   } catch (e: unknown) {